/*
* (c) The GRASP/AQUA Project, Glasgow University, 1994-2002
*
* hWaitForInput Runtime Support
*/
/* FD_SETSIZE defaults to 64 on Windows, which makes even the most basic
* programs break that use select() on a socket FD.
* Thus we raise it here (before any #include of network-related headers)
* to 1024 so that at least those programs would work that would work on
* Linux if that used select() (luckily it uses poll() by now).
* See https://gitlab.haskell.org/ghc/ghc/issues/13497#note_140304
* The real solution would be to remove all uses of select()
* on Windows, too, and use IO Completion Ports instead.
* Note that on Windows, one can simply define FD_SETSIZE to the desired
* size before including Winsock2.h, as described here:
* https://msdn.microsoft.com/en-us/library/windows/desktop/ms740141(v=vs.85).aspx
*/
#if defined(_WIN32)
#define FD_SETSIZE 1024
#endif
/* select and supporting types is not Posix */
/* #include <rts/PosixSource.h> */
#include <Rts.h>
#include <limits.h>
#include <stdbool.h>
#include "HsBase.h"
#if !defined(_WIN32)
#include <poll.h>
#endif
/*
* Returns a timeout suitable to be passed into poll().
*
* If `remaining` contains a fractional milliseconds part that cannot be passed
* to poll(), this function will return the next larger value that can, so
* that the timeout passed to poll() would always be `>= remaining`.
*
* If `infinite`, `remaining` is ignored.
*/
static inline
int
compute_poll_timeout(bool infinite, Time remaining)
{
if (infinite) return -1;
if (remaining < 0) return 0;
if (remaining > MSToTime(INT_MAX)) return INT_MAX;
int remaining_ms = TimeToMS(remaining);
if (remaining != MSToTime(remaining_ms)) return remaining_ms + 1;
return remaining_ms;
}
#if defined(_WIN32)
/*
* Returns a timeout suitable to be passed into select() on Windows.
*
* The given `remaining_tv` serves as a storage for the timeout
* when needed, but callers should use the returned value instead
* as it will not be filled in all cases.
*
* If `infinite`, `remaining` is ignored and `remaining_tv` not touched
* (and may be passed as NULL in that case).
*/
static inline
struct timeval *
compute_windows_select_timeout(bool infinite, Time remaining,
/* out */ struct timeval * remaining_tv)
{
if (infinite) {
return NULL;
}
ASSERT(remaining_tv);
if (remaining < 0) {
remaining_tv->tv_sec = 0;
remaining_tv->tv_usec = 0;
} else if (remaining > MSToTime(LONG_MAX)) {
remaining_tv->tv_sec = LONG_MAX;
remaining_tv->tv_usec = LONG_MAX;
} else {
remaining_tv->tv_sec = TimeToMS(remaining) / 1000;
remaining_tv->tv_usec = TimeToUS(remaining) % 1000000;
}
return remaining_tv;
}
/*
* Returns a timeout suitable to be passed into WaitForSingleObject() on
* Windows.
*
* If `remaining` contains a fractional milliseconds part that cannot be passed
* to WaitForSingleObject(), this function will return the next larger value
* that can, so that the timeout passed to WaitForSingleObject() would
* always be `>= remaining`.
*
* If `infinite`, `remaining` is ignored.
*/
static inline
DWORD
compute_WaitForSingleObject_timeout(bool infinite, Time remaining)
{
// WaitForSingleObject() has the fascinating delicacy behaviour
// that it waits indefinitely if the `DWORD dwMilliseconds`
// is set to 0xFFFFFFFF (the maximum DWORD value), which is
// 4294967295 seconds == ~49.71 days
// (the Windows API calls this constant INFINITE...).
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx
//
// We ensure that if accidentally `remaining == 4294967295`, it does
// NOT wait forever, by never passing that value to
// WaitForSingleObject() (so, never returning it from this function),
// unless `infinite`.
if (infinite) return INFINITE;
if (remaining < 0) return 0;
if (remaining >= MSToTime(INFINITE)) return INFINITE - 1;
DWORD remaining_ms = TimeToMS(remaining);
if (remaining != MSToTime(remaining_ms)) return remaining_ms + 1;
return remaining_ms;
}
#endif
/*
* inputReady(fd) checks to see whether input is available on the file
* descriptor 'fd' within 'msecs' milliseconds (or indefinitely if 'msecs' is
* negative). "Input is available" is defined as 'can I safely read at least a
* *character* from this file object without blocking?' (this does not work
* reliably on Linux when the fd is a not-O_NONBLOCK socket, so if you pass
* socket fds to this function, ensure they have O_NONBLOCK;
* see `man 2 poll` and `man 2 select`, and
* https://gitlab.haskell.org/ghc/ghc/issues/13497#note_140309).
*
* This function blocks until either `msecs` have passed, or input is
* available.
*
* Returns:
* 1 => Input ready, 0 => not ready, -1 => error
* On error, sets `errno`.
*/
int
fdReady(int fd, bool write, int64_t msecs, bool isSock)
{
bool infinite = msecs < 0;
// if we need to track the time then record the end time in case we are
// interrupted.
Time endTime = 0;
if (msecs > 0) {
endTime = getProcessElapsedTime() + MSToTime(msecs);
}
// Invariant of all code below:
// If `infinite`, then `remaining` and `endTime` are never used.
Time remaining = MSToTime(msecs);
// Note [Guaranteed syscall time spent]
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The implementation ensures that if fdReady() is called with N `msecs`,
// it will not return before an FD-polling syscall *returns*
// with `endTime` having passed.
//
// Consider the following scenario:
//
// 1 int ready = poll(..., msecs);
// 2 if (EINTR happened) {
// 3 Time now = getProcessElapsedTime();
// 4 if (now >= endTime) return 0;
// 5 remaining = endTime - now;
// 6 }
//
// If `msecs` is 5 seconds, but in line 1 poll() returns with EINTR after
// only 10 ms due to a signal, and if at line 2 the machine starts
// swapping for 10 seconds, then line 4 will return that there's no
// data ready, even though by now there may be data ready now, and we have
// not actually checked after up to `msecs` = 5 seconds whether there's
// data ready as promised.
//
// Why is this important?
// Assume you call the pizza man to bring you a pizza.
// You arrange that you won't pay if he doesn't ring your doorbell
// in under 10 minutes delivery time.
// At 9:58 fdReady() gets woken by EINTR and then your computer swaps
// for 3 seconds.
// At 9:59 the pizza man rings.
// At 10:01 fdReady() will incorrectly tell you that the pizza man hasn't
// rung within 10 minutes, when in fact he has.
//
// If the pizza man is some watchdog service or dead man's switch program,
// this is problematic.
//
// To avoid it, we ensure that in the timeline diagram:
//
// endTime
// |
// time ----+----------+-------+---->
// | |
// syscall starts syscall returns
//
// the "syscall returns" event is always >= the "endTime" time.
//
// In the code this means that we never check whether to `return 0`
// after a `Time now = getProcessElapsedTime();`, and instead always
// let the branch marked [we waited the full msecs] handle that case.
#if !defined(_WIN32)
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = write ? POLLOUT : POLLIN;
fds[0].revents = 0;
// The code below tries to make as few syscalls as possible;
// in particular, it eschews getProcessElapsedTime() calls
// when `infinite` or `msecs == 0`.
// We need to wait in a loop because poll() accepts `int` but `msecs` is
// `int64_t`, and because signals can interrupt it.
while (true) {
int res = poll(fds, 1, compute_poll_timeout(infinite, remaining));
if (res < 0 && errno != EINTR)
return (-1); // real error; errno is preserved
if (res > 0)
return 1; // FD has new data
if (res == 0 && !infinite && remaining <= MSToTime(INT_MAX))
return 0; // FD has no new data and [we waited the full msecs]
// Non-exit cases
CHECK( ( res < 0 && errno == EINTR ) || // EINTR happened
// need to wait more
( res == 0 && (infinite ||
remaining > MSToTime(INT_MAX)) ) );
if (!infinite) {
Time now = getProcessElapsedTime();
remaining = endTime - now;
}
}
#else
if (isSock) {
int maxfd;
fd_set rfd, wfd;
struct timeval remaining_tv;
if ((fd >= (int)FD_SETSIZE) || (fd < 0)) {
barf("fdReady: fd is too big: %d but FD_SETSIZE is %d", fd, (int)FD_SETSIZE);
}
FD_ZERO(&rfd);
FD_ZERO(&wfd);
if (write) {
FD_SET(fd, &wfd);
} else {
FD_SET(fd, &rfd);
}
/* select() will consider the descriptor set in the range of 0 to
* (maxfd-1)
*/
maxfd = fd + 1;
// We need to wait in a loop because the `timeval` `tv_*` members
// passed into select() accept are `long` (which is 32 bits on 32-bit
// and 64-bit Windows), but `msecs` is `int64_t`, and because signals
// can interrupt it.
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms740560(v=vs.85).aspx
// https://stackoverflow.com/questions/384502/what-is-the-bit-size-of-long-on-64-bit-windows#384672
while (true) {
int res = select(maxfd, &rfd, &wfd, NULL,
compute_windows_select_timeout(infinite, remaining,
&remaining_tv));
if (res < 0 && errno != EINTR)
return (-1); // real error; errno is preserved
if (res > 0)
return 1; // FD has new data
if (res == 0 && !infinite && remaining <= MSToTime(INT_MAX))
return 0; // FD has no new data and [we waited the full msecs]
// Non-exit cases
CHECK( ( res < 0 && errno == EINTR ) || // EINTR happened
// need to wait more
( res == 0 && (infinite ||
remaining > MSToTime(INT_MAX)) ) );
if (!infinite) {
Time now = getProcessElapsedTime();
remaining = endTime - now;
}
}
} else {
DWORD rc;
HANDLE hFile = (HANDLE)_get_osfhandle(fd);
DWORD avail = 0;
switch (GetFileType(hFile)) {
case FILE_TYPE_CHAR:
{
INPUT_RECORD buf[1];
DWORD count;
// nightmare. A Console Handle will appear to be ready
// (WaitForSingleObject() returned WAIT_OBJECT_0) when
// it has events in its input buffer, but these events might
// not be keyboard events, so when we read from the Handle the
// read() will block. So here we try to discard non-keyboard
// events from a console handle's input buffer and then try
// the WaitForSingleObject() again.
while (1) // keep trying until we find a real key event
{
rc = WaitForSingleObject(
hFile,
compute_WaitForSingleObject_timeout(infinite, remaining));
switch (rc) {
case WAIT_TIMEOUT:
// We need to use < here because if remaining
// was INFINITE, we'll have waited for
// `INFINITE - 1` as per
// compute_WaitForSingleObject_timeout(),
// so that's 1 ms too little. Wait again then.
if (!infinite && remaining < MSToTime(INFINITE))
return 0; // real complete or [we waited the full msecs]
goto waitAgain;
case WAIT_OBJECT_0: break;
default: /* WAIT_FAILED */ maperrno(); return -1;
}
while (1) // discard non-key events
{
BOOL success = PeekConsoleInput(hFile, buf, 1, &count);
// printf("peek, rc=%d, count=%d, type=%d\n", rc, count, buf[0].EventType);
if (!success) {
rc = GetLastError();
if (rc == ERROR_INVALID_HANDLE || rc == ERROR_INVALID_FUNCTION) {
return 1;
} else {
maperrno();
return -1;
}
}
if (count == 0) break; // no more events => wait again
// discard console events that are not "key down", because
// these will also be discarded by ReadFile().
if (buf[0].EventType == KEY_EVENT &&
buf[0].Event.KeyEvent.bKeyDown &&
buf[0].Event.KeyEvent.uChar.AsciiChar != '\0')
{
// it's a proper keypress:
return 1;
}
else
{
// it's a non-key event, a key up event, or a
// non-character key (e.g. shift). discard it.
BOOL success = ReadConsoleInput(hFile, buf, 1, &count);
if (!success) {
rc = GetLastError();
if (rc == ERROR_INVALID_HANDLE || rc == ERROR_INVALID_FUNCTION) {
return 1;
} else {
maperrno();
return -1;
}
}
}
}
Time now;
waitAgain:
now = getProcessElapsedTime();
remaining = endTime - now;
}
}
case FILE_TYPE_DISK:
// assume that disk files are always ready:
return 1;
case FILE_TYPE_PIPE: {
// WaitForMultipleObjects() doesn't work for pipes (it
// always returns WAIT_OBJECT_0 even when no data is
// available). If the HANDLE is a pipe, therefore, we try
// PeekNamedPipe():
//
// PeekNamedPipe() does not block, so if it returns that
// there is no new data, we have to sleep and try again.
// Because PeekNamedPipe() doesn't block, we have to track
// manually whether we've called it one more time after `endTime`
// to fulfill Note [Guaranteed syscall time spent].
bool endTimeReached = false;
while (avail == 0) {
BOOL success = PeekNamedPipe( hFile, NULL, 0, NULL, &avail, NULL );
if (success) {
if (avail != 0) {
return 1;
} else { // no new data
if (infinite) {
Sleep(1); // 1 millisecond (smallest possible time on Windows)
continue;
} else if (msecs == 0) {
return 0;
} else {
if (endTimeReached) return 0; // [we waited the full msecs]
Time now = getProcessElapsedTime();
if (now >= endTime) endTimeReached = true;
Sleep(1); // 1 millisecond (smallest possible time on Windows)
continue;
}
}
} else {
rc = GetLastError();
if (rc == ERROR_BROKEN_PIPE) {
return 1; // this is probably what we want
}
if (rc != ERROR_INVALID_HANDLE && rc != ERROR_INVALID_FUNCTION) {
maperrno();
return -1;
}
}
}
}
/* PeekNamedPipe didn't work - fall through to the general case */
default:
while (true) {
rc = WaitForSingleObject(
hFile,
compute_WaitForSingleObject_timeout(infinite, remaining));
switch (rc) {
case WAIT_TIMEOUT:
// We need to use < here because if remaining
// was INFINITE, we'll have waited for
// `INFINITE - 1` as per
// compute_WaitForSingleObject_timeout(),
// so that's 1 ms too little. Wait again then.
if (!infinite && remaining < MSToTime(INFINITE))
return 0; // real complete or [we waited the full msecs]
break;
case WAIT_OBJECT_0: return 1;
default: /* WAIT_FAILED */ maperrno(); return -1;
}
// EINTR or a >(INFINITE - 1) timeout completed
if (!infinite) {
Time now = getProcessElapsedTime();
remaining = endTime - now;
}
}
}
}
#endif
}