45#if defined(TARGET_DARWIN)
46#define SELECT_PREFERRED_OVER_POLL
63#define SELECT_MAX_FDS FD_SETSIZE
65#define SELECT_MAX_FDS 256
80 if (tv->tv_sec == 0 && tv->tv_usec == 0)
87 return max_int((
int)(tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000), 1);
106 ASSERT(i >= 0 && i < wes->capacity);
111 wes->
events[i] =
event->read;
116 wes->
events[i] =
event->write;
163 for (i = 0; i < len; ++i)
165 const HANDLE h = wes->
events[i];
166 if (h == event->
read || h == event->
write)
175 wes->
esr[j] = wes->
esr[i];
186 ASSERT(index >= 0 && index < wes->n_events);
187 for (i = index; i < wes->
n_events - 1; ++i)
190 wes->
esr[i] = wes->
esr[i + 1];
202 const HANDLE h = wes->
events[i];
203 if (h == event->
read)
208 else if (h == event->
write)
381 msg(
M_FATAL,
"fatal error in we_ctl: rwflags=%u", rwflags);
388 "Error: Windows resource limit WSA_MAXIMUM_WAIT_EVENTS (%d) has been exceeded",
389 WSA_MAXIMUM_WAIT_EVENTS);
416#pragma GCC diagnostic push
417#pragma GCC diagnostic ignored "-Wtype-limits"
439 if (WaitForSingleObject(wes->
events[i], 0) == WAIT_OBJECT_0)
464 (DWORD)timeout, FALSE);
467 if (outlen >= 1 &&
status >= WSA_WAIT_EVENT_0
470 *out = wes->
esr[
status - WSA_WAIT_EVENT_0];
475 else if (
status == WSA_WAIT_TIMEOUT)
485#pragma GCC diagnostic pop
489#if defined(__GNUC__) || defined(__clang__)
490#pragma GCC diagnostic push
491#pragma GCC diagnostic ignored "-Wsign-conversion"
519 *maxevents =
min_int(*maxevents, WSA_MAXIMUM_WAIT_EVENTS);
532#if defined(__GNUC__) || defined(__clang__)
533#pragma GCC diagnostic pop
538#if defined(__GNUC__) || defined(__clang__)
539#pragma GCC diagnostic push
540#pragma GCC diagnostic ignored "-Wsign-conversion"
547 struct event_set_functions func;
551 struct epoll_event *events;
557 struct ep_set *eps = (
struct ep_set *)es;
566 const struct ep_set *eps = (
struct ep_set *)es;
573 struct epoll_event ev;
574 const struct ep_set *eps = (
struct ep_set *)es;
580 if (epoll_ctl(eps->epfd, EPOLL_CTL_DEL, event, &ev) < 0)
582 msg(
M_WARN |
M_ERRNO,
"EVENT: epoll_ctl EPOLL_CTL_DEL failed, sd=%d", (
int)event);
589 const struct ep_set *eps = (
struct ep_set *)es;
590 struct epoll_event ev;
597 ev.events |= EPOLLIN;
601 ev.events |= EPOLLOUT;
605 (
unsigned int)ev.events, (
ptr_type)ev.data.ptr);
607 if (epoll_ctl(eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0)
611 if (epoll_ctl(eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0)
613 msg(
M_ERR,
"EVENT: epoll_ctl EPOLL_CTL_ADD failed, sd=%d", (
int)event);
618 msg(
M_ERR,
"EVENT: epoll_ctl EPOLL_CTL_MOD failed, sd=%d", (
int)event);
626 struct ep_set *eps = (
struct ep_set *)es;
629 if (outlen > eps->maxevents)
631 outlen = eps->maxevents;
640 const struct epoll_event *ev = eps->events;
642 for (i = 0; i < stat; ++i)
645 if (ev->events & (EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP))
649 if (ev->events & EPOLLOUT)
653 esr->
arg = ev->data.ptr;
664ep_init(
int *maxevents,
unsigned int flags)
672 fd = epoll_create(*maxevents);
683 eps->func.free = ep_free;
684 eps->func.reset = ep_reset;
685 eps->func.del = ep_del;
686 eps->func.ctl = ep_ctl;
687 eps->func.wait = ep_wait;
697 eps->maxevents = *maxevents;
711 struct event_set_functions func;
713 struct pollfd *events;
722 struct po_set *
pos = (
struct po_set *)es;
731 struct po_set *
pos = (
struct po_set *)es;
739 struct po_set *
pos = (
struct po_set *)es;
745 for (i = 0; i <
pos->n_events; ++i)
747 if (
pos->events[i].fd == event)
750 for (j = i; j <
pos->n_events - 1; ++j)
752 pos->events[j] =
pos->events[j + 1];
753 pos->args[j] =
pos->args[j + 1];
762po_set_pollfd_events(
struct pollfd *pfdp,
unsigned int rwflags)
767 pfdp->events |= POLLOUT;
771 pfdp->events |= (POLLIN | POLLPRI);
776po_append_event(
struct po_set *
pos,
event_t event,
unsigned int rwflags,
void *arg)
778 if (
pos->n_events <
pos->capacity)
780 struct pollfd *pfdp = &
pos->events[
pos->n_events];
782 pos->args[
pos->n_events] = arg;
783 po_set_pollfd_events(pfdp, rwflags);
796 struct po_set *
pos = (
struct po_set *)es;
803 if (!po_append_event(
pos, event, rwflags, arg))
811 for (i = 0; i <
pos->n_events; ++i)
813 struct pollfd *pfdp = &
pos->events[i];
814 if (pfdp->fd == event)
817 po_set_pollfd_events(pfdp, rwflags);
821 if (!po_append_event(
pos, event, rwflags, arg))
837 struct po_set *
pos = (
struct po_set *)es;
842 ASSERT(stat <= pos->n_events);
847 const struct pollfd *pfdp =
pos->events;
848 for (i = 0; i <
pos->n_events && j < outlen; ++i)
850 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP | POLLOUT))
853 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP))
857 if (pfdp->revents & POLLOUT)
863 "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s", i, j,
865 pos->fast ?
"" :
"[scalable]");
869 else if (pfdp->revents)
872 (
unsigned int)pfdp->revents, pfdp->fd);
882po_init(
int *maxevents,
unsigned int flags)
891 pos->func.free = po_free;
892 pos->func.reset = po_reset;
893 pos->func.del = po_del;
894 pos->func.ctl = po_ctl;
895 pos->func.wait = po_wait;
906 pos->capacity = *maxevents;
922 struct event_set_functions func;
934 struct se_set *ses = (
struct se_set *)es;
942 struct se_set *ses = (
struct se_set *)es;
948 FD_ZERO(&ses->readfds);
949 FD_ZERO(&ses->writefds);
950 for (i = 0; i <= ses->maxfd; ++i)
960 struct se_set *ses = (
struct se_set *)es;
965 if (event >= 0 && event < ses->capacity)
967 FD_CLR(event, &ses->readfds);
968 FD_CLR(event, &ses->writefds);
969 ses->args[event] = NULL;
981 struct se_set *ses = (
struct se_set *)es;
984 rwflags, (
int)event, (
int)ses->fast, ses->capacity, ses->maxfd, (
ptr_type)arg);
986 if (event >= 0 && event < ses->capacity)
988 ses->maxfd =
max_int(event, ses->maxfd);
989 ses->args[event] = arg;
1009 FD_CLR(event, &ses->readfds);
1017 FD_CLR(event, &ses->writefds);
1023 msg(
D_EVENT_ERRORS,
"Error: select: too many I/O wait events, fd=%d cap=%d", (
int)event,
1033 for (i = 0; i <= ses->maxfd && j < outlen; ++i)
1035 const bool r = FD_ISSET(i,
read);
1036 const bool w = FD_ISSET(i,
write);
1048 out->
arg = ses->args[i];
1062 struct se_set *ses = (
struct se_set *)es;
1063 struct timeval tv_tmp = *tv;
1067 (int64_t)tv_tmp.tv_sec, (
long)tv_tmp.tv_usec);
1069 stat = select(ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp);
1073 stat = se_wait_return(ses, &ses->readfds, &ses->writefds, out, outlen);
1083 struct se_set *ses = (
struct se_set *)es;
1084 struct timeval tv_tmp = *tv;
1085 fd_set
read = ses->readfds;
1086 fd_set
write = ses->writefds;
1089 dmsg(
D_EVENT_WAIT,
"SE_WAIT_SCALEABLE maxfd=%d tv=%" PRIi64
"/%ld", ses->maxfd,
1090 (int64_t)tv_tmp.tv_sec, (
long)tv_tmp.tv_usec);
1092 stat = select(ses->maxfd + 1, &
read, &
write, NULL, &tv_tmp);
1096 stat = se_wait_return(ses, &
read, &
write, out, outlen);
1103se_init(
int *maxevents,
unsigned int flags)
1107 dmsg(
D_EVENT_WAIT,
"SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
1112 ses->func.free = se_free;
1113 ses->func.reset = se_reset;
1114 ses->func.del = se_del;
1115 ses->func.ctl = se_ctl;
1116 ses->func.wait = se_wait_scalable;
1121 ses->func.wait = se_wait_fast;
1139#if defined(__GNUC__) || defined(__clang__)
1140#pragma GCC diagnostic pop
1148 ret =
we_init(maxevents, flags);
1153 ret = se_init(maxevents, flags);
1156#ifdef SELECT_PREFERRED_OVER_POLL
1159 ret = se_init(maxevents, flags);
1163 ret = po_init(maxevents, flags);
1168 ret = po_init(maxevents, flags);
1172 ret = se_init(maxevents, flags);
1176 ret = po_init(maxevents, flags);
1178 ret = se_init(maxevents, flags);
1180#error At least one of poll, select, or WSAWaitForMultipleEvents must be supported by the kernel
1191 ret = ep_init(maxevents, flags);
1194 msg(
M_WARN,
"Note: sys_epoll API is unavailable, falling back to poll/select API");
Buffer management functions and garbage collection.
#define ALLOC_ARRAY_CLEAR(dptr, type, n)
Allocate and zero-initialise an array of n elements of the given type.
#define ALLOC_OBJ_CLEAR(dptr, type)
Allocate and zero-initialise memory for a single object of the given type.
static bool we_append_event(struct we_set *wes, event_t event, unsigned int rwflags, void *arg)
static struct event_set * event_set_init_simple(int *maxevents, unsigned int flags)
static void we_free(struct event_set *es)
static void we_get_rw_indices(struct we_set *wes, event_t event, int *ri, int *wi)
static void we_del_index(struct we_set *wes, int index)
static int tv_to_ms_timeout(const struct timeval *tv)
Convert timeval value (which is in seconds and microseconds) to a value of milliseconds which is requ...
static struct event_set * event_set_init_scalable(int *maxevents, unsigned int flags)
static void we_del(struct event_set *es, event_t event)
static int we_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
static void we_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
static struct event_set * we_init(int *maxevents, unsigned int flags)
struct event_set * event_set_init(int *maxevents, unsigned int flags)
static void we_del_event(struct we_set *wes, event_t event)
static void we_set_event(struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg)
static void we_reset(struct event_set *es)
#define EVENT_METHOD_FAST
#define EVENT_METHOD_US_TIMEOUT
const struct rw_handle * event_t
void set_cloexec(socket_descriptor_t fd)
static void openvpn_fd_set(socket_descriptor_t fd, fd_set *setp)
static int min_int(int x, int y)
static int max_int(int x, int y)
static SERVICE_STATUS status
static bool check_debug_level(msglvl_t level)
void(* ctl)(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
int(* wait)(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
void(* del)(struct event_set *es, event_t event)
void(* reset)(struct event_set *es)
void(* free)(struct event_set *es)
struct event_set_return * esr
struct event_set_functions func