/**
|
* \file
|
*/
|
|
#include "utils/mono-poll.h"
|
|
static mono_pollfd *poll_fds;
|
static guint poll_fds_capacity;
|
static guint poll_fds_size;
|
|
static inline void
|
POLL_INIT_FD (mono_pollfd *poll_fd, gint fd, gint events)
|
{
|
poll_fd->fd = fd;
|
poll_fd->events = events;
|
poll_fd->revents = 0;
|
}
|
|
static gboolean
|
poll_init (gint wakeup_pipe_fd)
|
{
|
g_assert (wakeup_pipe_fd >= 0);
|
|
poll_fds_size = 1;
|
poll_fds_capacity = 64;
|
|
poll_fds = g_new0 (mono_pollfd, poll_fds_capacity);
|
|
POLL_INIT_FD (&poll_fds [0], wakeup_pipe_fd, MONO_POLLIN);
|
|
return TRUE;
|
}
|
|
static void
|
poll_register_fd (gint fd, gint events, gboolean is_new)
|
{
|
gint i;
|
gint poll_event;
|
|
g_assert (fd >= 0);
|
g_assert (poll_fds_size <= poll_fds_capacity);
|
|
g_assert ((events & ~(EVENT_IN | EVENT_OUT)) == 0);
|
|
poll_event = 0;
|
if (events & EVENT_IN)
|
poll_event |= MONO_POLLIN;
|
if (events & EVENT_OUT)
|
poll_event |= MONO_POLLOUT;
|
|
for (i = 0; i < poll_fds_size; ++i) {
|
if (poll_fds [i].fd == fd) {
|
g_assert (!is_new);
|
POLL_INIT_FD (&poll_fds [i], fd, poll_event);
|
return;
|
}
|
}
|
|
g_assert (is_new);
|
|
for (i = 0; i < poll_fds_size; ++i) {
|
if (poll_fds [i].fd == -1) {
|
POLL_INIT_FD (&poll_fds [i], fd, poll_event);
|
return;
|
}
|
}
|
|
poll_fds_size += 1;
|
|
if (poll_fds_size > poll_fds_capacity) {
|
poll_fds_capacity *= 2;
|
g_assert (poll_fds_size <= poll_fds_capacity);
|
|
poll_fds = (mono_pollfd *)g_renew (mono_pollfd, poll_fds, poll_fds_capacity);
|
}
|
|
POLL_INIT_FD (&poll_fds [poll_fds_size - 1], fd, poll_event);
|
}
|
|
static void
|
poll_remove_fd (gint fd)
|
{
|
gint i;
|
|
g_assert (fd >= 0);
|
|
for (i = 0; i < poll_fds_size; ++i) {
|
if (poll_fds [i].fd == fd) {
|
POLL_INIT_FD (&poll_fds [i], -1, 0);
|
break;
|
}
|
}
|
|
/* if we don't find the fd in poll_fds,
|
* it means we try to delete it twice */
|
g_assert (i < poll_fds_size);
|
|
/* if we find it again, it means we added
|
* it twice */
|
for (; i < poll_fds_size; ++i)
|
g_assert (poll_fds [i].fd != fd);
|
|
/* reduce the value of poll_fds_size so we
|
* do not keep it too big */
|
while (poll_fds_size > 1 && poll_fds [poll_fds_size - 1].fd == -1)
|
poll_fds_size -= 1;
|
}
|
|
static inline gint
|
poll_mark_bad_fds (mono_pollfd *poll_fds, gint poll_fds_size)
|
{
|
gint i, ready = 0;
|
|
for (i = 0; i < poll_fds_size; i++) {
|
if (poll_fds [i].fd == -1)
|
continue;
|
|
switch (mono_poll (&poll_fds [i], 1, 0)) {
|
case 1:
|
ready++;
|
break;
|
case -1:
|
if (errno == EBADF)
|
{
|
poll_fds [i].revents |= MONO_POLLNVAL;
|
ready++;
|
}
|
break;
|
}
|
}
|
|
return ready;
|
}
|
|
static gint
|
poll_event_wait (void (*callback) (gint fd, gint events, gpointer user_data), gpointer user_data)
|
{
|
gint i, ready;
|
|
for (i = 0; i < poll_fds_size; ++i)
|
poll_fds [i].revents = 0;
|
|
mono_gc_set_skip_thread (TRUE);
|
|
MONO_ENTER_GC_SAFE;
|
ready = mono_poll (poll_fds, poll_fds_size, -1);
|
MONO_EXIT_GC_SAFE;
|
|
mono_gc_set_skip_thread (FALSE);
|
|
if (ready == -1) {
|
/*
|
* Apart from EINTR, we only check EBADF, for the rest:
|
* EINVAL: mono_poll() 'protects' us from descriptor
|
* numbers above the limit if using select() by marking
|
* then as POLLERR. If a system poll() is being
|
* used, the number of descriptor we're passing will not
|
* be over sysconf(_SC_OPEN_MAX), as the error would have
|
* happened when opening.
|
*
|
* EFAULT: we own the memory pointed by pfds.
|
* ENOMEM: we're doomed anyway
|
*
|
*/
|
switch (errno)
|
{
|
case EINTR:
|
{
|
ready = 0;
|
break;
|
}
|
case EBADF:
|
{
|
ready = poll_mark_bad_fds (poll_fds, poll_fds_size);
|
break;
|
}
|
default:
|
g_error ("poll_event_wait: mono_poll () failed, error (%d) %s", errno, g_strerror (errno));
|
break;
|
}
|
}
|
|
if (ready == -1)
|
return -1;
|
if (ready == 0)
|
return 0;
|
|
g_assert (ready > 0);
|
|
for (i = 0; i < poll_fds_size; ++i) {
|
gint fd, events = 0;
|
|
if (poll_fds [i].fd == -1)
|
continue;
|
if (poll_fds [i].revents == 0)
|
continue;
|
|
fd = poll_fds [i].fd;
|
if (poll_fds [i].revents & (MONO_POLLIN | MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL))
|
events |= EVENT_IN;
|
if (poll_fds [i].revents & (MONO_POLLOUT | MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL))
|
events |= EVENT_OUT;
|
if (poll_fds [i].revents & (MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL))
|
events |= EVENT_ERR;
|
|
callback (fd, events, user_data);
|
|
if (--ready == 0)
|
break;
|
}
|
|
return 0;
|
}
|
|
static ThreadPoolIOBackend backend_poll = {
|
.init = poll_init,
|
.register_fd = poll_register_fd,
|
.remove_fd = poll_remove_fd,
|
.event_wait = poll_event_wait,
|
};
|
