/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#if defined(_PR_PTHREADS)
# error
"This file should not be compiled"
#else /* defined(_PR_PTHREADS) */
# include
"primpl.h"
# include <sys/time.h>
# include <fcntl.h>
# ifdef _PR_USE_POLL
# include <poll.h>
# endif
# if defined(_PR_USE_POLL)
static PRInt32 NativeThreadPoll(PRPollDesc* pds, PRIntn npds,
PRIntervalTime timeout) {
/*
* This function is mostly duplicated from ptio.s's PR_Poll().
*/
PRInt32 ready = 0;
/*
* For restarting poll() if it is interrupted by a signal.
* We use these variables to figure out how much time has
* elapsed and how much of the timeout still remains.
*/
PRIntn index, msecs;
struct pollfd* syspoll = NULL;
PRIntervalTime start, elapsed, remaining;
syspoll = (
struct pollfd*)PR_MALLOC(npds *
sizeof(
struct pollfd));
if (NULL == syspoll) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return -1;
}
for (index = 0; index < npds; ++index) {
PRFileDesc* bottom;
PRInt16 in_flags_read = 0, in_flags_write = 0;
PRInt16 out_flags_read = 0, out_flags_write = 0;
if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) {
if (pds[index].in_flags & PR_POLL_READ) {
in_flags_read = (pds[index].fd->methods->poll)(
pds[index].fd, pds[index].in_flags & ~PR_POLL_WRITE,
&out_flags_read);
}
if (pds[index].in_flags & PR_POLL_WRITE) {
in_flags_write = (pds[index].fd->methods->poll)(
pds[index].fd, pds[index].in_flags & ~PR_POLL_READ,
&out_flags_write);
}
if ((0 != (in_flags_read & out_flags_read)) ||
(0 != (in_flags_write & out_flags_write))) {
/* this one is ready right now */
if (0 == ready) {
/*
* We will return without calling the system
* poll function. So zero the out_flags
* fields of all the poll descriptors before
* this one.
*/
int i;
for (i = 0; i < index; i++) {
pds[i].out_flags = 0;
}
}
ready += 1;
pds[index].out_flags = out_flags_read | out_flags_write;
}
else {
pds[index].out_flags = 0;
/* pre-condition */
/* now locate the NSPR layer at the bottom of the stack */
bottom = PR_GetIdentitiesLayer(pds[index].fd, PR_NSPR_IO_LAYER);
PR_ASSERT(NULL != bottom);
/* what to do about that? */
if ((NULL != bottom) && (_PR_FILEDESC_OPEN == bottom->secret->state)) {
if (0 == ready) {
syspoll[index].fd = bottom->secret->md.osfd;
syspoll[index].events = 0;
/* pre-condition */
if (in_flags_read & PR_POLL_READ) {
pds[index].out_flags |= _PR_POLL_READ_SYS_READ;
syspoll[index].events |= POLLIN;
}
if (in_flags_read & PR_POLL_WRITE) {
pds[index].out_flags |= _PR_POLL_READ_SYS_WRITE;
syspoll[index].events |= POLLOUT;
}
if (in_flags_write & PR_POLL_READ) {
pds[index].out_flags |= _PR_POLL_WRITE_SYS_READ;
syspoll[index].events |= POLLIN;
}
if (in_flags_write & PR_POLL_WRITE) {
pds[index].out_flags |= _PR_POLL_WRITE_SYS_WRITE;
syspoll[index].events |= POLLOUT;
}
if (pds[index].in_flags & PR_POLL_EXCEPT) {
syspoll[index].events |= POLLPRI;
}
}
}
else {
if (0 == ready) {
int i;
for (i = 0; i < index; i++) {
pds[i].out_flags = 0;
}
}
ready += 1;
/* this will cause an abrupt return */
pds[index].out_flags = PR_POLL_NVAL;
/* bogii */
}
}
}
else {
/* make poll() ignore this entry */
syspoll[index].fd = -1;
syspoll[index].events = 0;
pds[index].out_flags = 0;
}
}
if (0 == ready) {
switch (timeout) {
case PR_INTERVAL_NO_WAIT:
msecs = 0;
break;
case PR_INTERVAL_NO_TIMEOUT:
msecs = -1;
break;
default:
msecs = PR_IntervalToMilliseconds(timeout);
start = PR_IntervalNow();
}
retry:
ready = _MD_POLL(syspoll, npds, msecs);
if (-1 == ready) {
PRIntn oserror = errno;
if (EINTR == oserror) {
if (timeout == PR_INTERVAL_NO_TIMEOUT) {
goto retry;
}
else if (timeout == PR_INTERVAL_NO_WAIT) {
ready = 0;
}
else {
elapsed = (PRIntervalTime)(PR_IntervalNow() - start);
if (elapsed > timeout) {
ready = 0;
/* timed out */
}
else {
remaining = timeout - elapsed;
msecs = PR_IntervalToMilliseconds(remaining);
goto retry;
}
}
}
else {
_PR_MD_MAP_POLL_ERROR(oserror);
}
}
else if (ready > 0) {
for (index = 0; index < npds; ++index) {
PRInt16 out_flags = 0;
if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) {
if (0 != syspoll[index].revents) {
/*
** Set up the out_flags so that it contains the
** bits that the highest layer thinks are nice
** to have. Then the client of that layer will
** call the appropriate I/O function and maybe
** the protocol will make progress.
*/
if (syspoll[index].revents & POLLIN) {
if (pds[index].out_flags & _PR_POLL_READ_SYS_READ) {
out_flags |= PR_POLL_READ;
}
if (pds[index].out_flags & _PR_POLL_WRITE_SYS_READ) {
out_flags |= PR_POLL_WRITE;
}
}
if (syspoll[index].revents & POLLOUT) {
if (pds[index].out_flags & _PR_POLL_READ_SYS_WRITE) {
out_flags |= PR_POLL_READ;
}
if (pds[index].out_flags & _PR_POLL_WRITE_SYS_WRITE) {
out_flags |= PR_POLL_WRITE;
}
}
if (syspoll[index].revents & POLLPRI) {
out_flags |= PR_POLL_EXCEPT;
}
if (syspoll[index].revents & POLLERR) {
out_flags |= PR_POLL_ERR;
}
if (syspoll[index].revents & POLLNVAL) {
out_flags |= PR_POLL_NVAL;
}
if (syspoll[index].revents & POLLHUP) {
out_flags |= PR_POLL_HUP;
}
}
}
pds[index].out_flags = out_flags;
}
}
}
PR_DELETE(syspoll);
return ready;
}
/* NativeThreadPoll */
# endif
/* defined(_PR_USE_POLL) */
# if !
defined(_PR_USE_POLL)
static PRInt32 NativeThreadSelect(PRPollDesc* pds, PRIntn npds,
PRIntervalTime timeout) {
/*
* This code is almost a duplicate of w32poll.c's _PR_MD_PR_POLL().
*/
fd_set rd, wt, ex;
PRFileDesc* bottom;
PRPollDesc *pd, *epd;
PRInt32 maxfd = -1, ready, err;
PRIntervalTime remaining, elapsed, start;
struct timeval tv, *tvp = NULL;
FD_ZERO(&rd);
FD_ZERO(&wt);
FD_ZERO(&ex);
ready = 0;
for (pd = pds, epd = pd + npds; pd < epd; pd++) {
PRInt16 in_flags_read = 0, in_flags_write = 0;
PRInt16 out_flags_read = 0, out_flags_write = 0;
if ((NULL != pd->fd) && (0 != pd->in_flags)) {
if (pd->in_flags & PR_POLL_READ) {
in_flags_read = (pd->fd->methods->poll)(
pd->fd, pd->in_flags & ~PR_POLL_WRITE, &out_flags_read);
}
if (pd->in_flags & PR_POLL_WRITE) {
in_flags_write = (pd->fd->methods->poll)(
pd->fd, pd->in_flags & ~PR_POLL_READ, &out_flags_write);
}
if ((0 != (in_flags_read & out_flags_read)) ||
(0 != (in_flags_write & out_flags_write))) {
/* this one's ready right now */
if (0 == ready) {
/*
* We will have to return without calling the
* system poll/select function. So zero the
* out_flags fields of all the poll descriptors
* before this one.
*/
PRPollDesc* prev;
for (prev = pds; prev < pd; prev++) {
prev->out_flags = 0;
}
}
ready += 1;
pd->out_flags = out_flags_read | out_flags_write;
}
else {
pd->out_flags = 0;
/* pre-condition */
/* make sure this is an NSPR supported stack */
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
PR_ASSERT(NULL != bottom);
/* what to do about that? */
if ((NULL != bottom) && (_PR_FILEDESC_OPEN == bottom->secret->state)) {
if (0 == ready) {
PRInt32 osfd = bottom->secret->md.osfd;
if (osfd > maxfd) {
maxfd = osfd;
}
if (in_flags_read & PR_POLL_READ) {
pd->out_flags |= _PR_POLL_READ_SYS_READ;
FD_SET(osfd, &rd);
}
if (in_flags_read & PR_POLL_WRITE) {
pd->out_flags |= _PR_POLL_READ_SYS_WRITE;
FD_SET(osfd, &wt);
}
if (in_flags_write & PR_POLL_READ) {
pd->out_flags |= _PR_POLL_WRITE_SYS_READ;
FD_SET(osfd, &rd);
}
if (in_flags_write & PR_POLL_WRITE) {
pd->out_flags |= _PR_POLL_WRITE_SYS_WRITE;
FD_SET(osfd, &wt);
}
if (pd->in_flags & PR_POLL_EXCEPT) {
FD_SET(osfd, &ex);
}
}
}
else {
if (0 == ready) {
PRPollDesc* prev;
for (prev = pds; prev < pd; prev++) {
prev->out_flags = 0;
}
}
ready += 1;
/* this will cause an abrupt return */
pd->out_flags = PR_POLL_NVAL;
/* bogii */
}
}
}
else {
pd->out_flags = 0;
}
}
if (0 != ready) {
return ready;
/* no need to block */
}
remaining = timeout;
start = PR_IntervalNow();
retry:
if (timeout != PR_INTERVAL_NO_TIMEOUT) {
PRInt32 ticksPerSecond = PR_TicksPerSecond();
tv.tv_sec = remaining / ticksPerSecond;
tv.tv_usec = PR_IntervalToMicroseconds(remaining % ticksPerSecond);
tvp = &tv;
}
ready = _MD_SELECT(maxfd + 1, &rd, &wt, &ex, tvp);
if (ready == -1 && errno == EINTR) {
if (timeout == PR_INTERVAL_NO_TIMEOUT) {
goto retry;
}
else {
elapsed = (PRIntervalTime)(PR_IntervalNow() - start);
if (elapsed > timeout) {
ready = 0;
/* timed out */
}
else {
remaining = timeout - elapsed;
goto retry;
}
}
}
/*
** Now to unravel the select sets back into the client's poll
** descriptor list. Is this possibly an area for pissing away
** a few cycles or what?
*/
if (ready > 0) {
ready = 0;
for (pd = pds, epd = pd + npds; pd < epd; pd++) {
PRInt16 out_flags = 0;
if ((NULL != pd->fd) && (0 != pd->in_flags)) {
PRInt32 osfd;
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
PR_ASSERT(NULL != bottom);
osfd = bottom->secret->md.osfd;
if (FD_ISSET(osfd, &rd)) {
if (pd->out_flags & _PR_POLL_READ_SYS_READ) {
out_flags |= PR_POLL_READ;
}
if (pd->out_flags & _PR_POLL_WRITE_SYS_READ) {
out_flags |= PR_POLL_WRITE;
}
}
if (FD_ISSET(osfd, &wt)) {
if (pd->out_flags & _PR_POLL_READ_SYS_WRITE) {
out_flags |= PR_POLL_READ;
}
if (pd->out_flags & _PR_POLL_WRITE_SYS_WRITE) {
out_flags |= PR_POLL_WRITE;
}
}
if (FD_ISSET(osfd, &ex)) {
out_flags |= PR_POLL_EXCEPT;
}
}
pd->out_flags = out_flags;
if (out_flags) {
ready++;
}
}
PR_ASSERT(ready > 0);
}
else if (ready < 0) {
err = _MD_ERRNO();
if (err == EBADF) {
/* Find the bad fds */
ready = 0;
for (pd = pds, epd = pd + npds; pd < epd; pd++) {
pd->out_flags = 0;
if ((NULL != pd->fd) && (0 != pd->in_flags)) {
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
if (fcntl(bottom->secret->md.osfd, F_GETFL, 0) == -1) {
pd->out_flags = PR_POLL_NVAL;
ready++;
}
}
}
PR_ASSERT(ready > 0);
}
else {
_PR_MD_MAP_SELECT_ERROR(err);
}
}
return ready;
}
/* NativeThreadSelect */
# endif
/* !defined(_PR_USE_POLL) */
static PRInt32 LocalThreads(PRPollDesc* pds, PRIntn npds,
PRIntervalTime timeout) {
PRPollDesc *pd, *epd;
PRInt32 ready, pdcnt;
_PRUnixPollDesc *unixpds, *unixpd;
/*
* XXX
* PRPollDesc has a PRFileDesc field, fd, while the IOQ
* is a list of PRPollQueue structures, each of which contains
* a _PRUnixPollDesc. A _PRUnixPollDesc struct contains
* the OS file descriptor, osfd, and not a PRFileDesc.
* So, we have allocate memory for _PRUnixPollDesc structures,
* copy the flags information from the pds list and have pq
* point to this list of _PRUnixPollDesc structures.
*
* It would be better if the memory allocation can be avoided.
*/
unixpd = unixpds =
(_PRUnixPollDesc*)PR_MALLOC(npds *
sizeof(_PRUnixPollDesc));
if (NULL == unixpds) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return -1;
}
ready = 0;
for (pdcnt = 0, pd = pds, epd = pd + npds; pd < epd; pd++) {
PRFileDesc* bottom;
PRInt16 in_flags_read = 0, in_flags_write = 0;
PRInt16 out_flags_read = 0, out_flags_write = 0;
if ((NULL != pd->fd) && (0 != pd->in_flags)) {
if (pd->in_flags & PR_POLL_READ) {
in_flags_read = (pd->fd->methods->poll)(
pd->fd, pd->in_flags & ~PR_POLL_WRITE, &out_flags_read);
}
if (pd->in_flags & PR_POLL_WRITE) {
in_flags_write = (pd->fd->methods->poll)(
pd->fd, pd->in_flags & ~PR_POLL_READ, &out_flags_write);
}
if ((0 != (in_flags_read & out_flags_read)) ||
(0 != (in_flags_write & out_flags_write))) {
/* this one's ready right now */
if (0 == ready) {
/*
* We will have to return without calling the
* system poll/select function. So zero the
* out_flags fields of all the poll descriptors
* before this one.
*/
PRPollDesc* prev;
for (prev = pds; prev < pd; prev++) {
prev->out_flags = 0;
}
}
ready += 1;
pd->out_flags = out_flags_read | out_flags_write;
}
else {
pd->out_flags = 0;
/* pre-condition */
bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
PR_ASSERT(NULL != bottom);
/* what to do about that? */
if ((NULL != bottom) && (_PR_FILEDESC_OPEN == bottom->secret->state)) {
if (0 == ready) {
unixpd->osfd = bottom->secret->md.osfd;
unixpd->in_flags = 0;
if (in_flags_read & PR_POLL_READ) {
unixpd->in_flags |= _PR_UNIX_POLL_READ;
pd->out_flags |= _PR_POLL_READ_SYS_READ;
}
if (in_flags_read & PR_POLL_WRITE) {
unixpd->in_flags |= _PR_UNIX_POLL_WRITE;
pd->out_flags |= _PR_POLL_READ_SYS_WRITE;
}
if (in_flags_write & PR_POLL_READ) {
unixpd->in_flags |= _PR_UNIX_POLL_READ;
pd->out_flags |= _PR_POLL_WRITE_SYS_READ;
}
if (in_flags_write & PR_POLL_WRITE) {
unixpd->in_flags |= _PR_UNIX_POLL_WRITE;
pd->out_flags |= _PR_POLL_WRITE_SYS_WRITE;
}
if ((in_flags_read | in_flags_write) & PR_POLL_EXCEPT) {
unixpd->in_flags |= _PR_UNIX_POLL_EXCEPT;
}
unixpd++;
pdcnt++;
}
}
else {
if (0 == ready) {
PRPollDesc* prev;
for (prev = pds; prev < pd; prev++) {
prev->out_flags = 0;
}
}
ready += 1;
/* this will cause an abrupt return */
pd->out_flags = PR_POLL_NVAL;
/* bogii */
}
}
}
}
if (0 != ready) {
/* no need to block */
PR_DELETE(unixpds);
return ready;
}
ready = _PR_WaitForMultipleFDs(unixpds, pdcnt, timeout);
/*
* Copy the out_flags from the _PRUnixPollDesc structures to the
* user's PRPollDesc structures and free the allocated memory
*/
unixpd = unixpds;
for (pd = pds, epd = pd + npds; pd < epd; pd++) {
PRInt16 out_flags = 0;
if ((NULL != pd->fd) && (0 != pd->in_flags)) {
/*
* take errors from the poll operation,
* the R/W bits from the request
*/
if (0 != unixpd->out_flags) {
if (unixpd->out_flags & _PR_UNIX_POLL_READ) {
if (pd->out_flags & _PR_POLL_READ_SYS_READ) {
out_flags |= PR_POLL_READ;
}
if (pd->out_flags & _PR_POLL_WRITE_SYS_READ) {
out_flags |= PR_POLL_WRITE;
}
}
if (unixpd->out_flags & _PR_UNIX_POLL_WRITE) {
if (pd->out_flags & _PR_POLL_READ_SYS_WRITE) {
out_flags |= PR_POLL_READ;
}
if (pd->out_flags & _PR_POLL_WRITE_SYS_WRITE) {
out_flags |= PR_POLL_WRITE;
}
}
if (unixpd->out_flags & _PR_UNIX_POLL_EXCEPT) {
out_flags |= PR_POLL_EXCEPT;
}
if (unixpd->out_flags & _PR_UNIX_POLL_ERR) {
out_flags |= PR_POLL_ERR;
}
if (unixpd->out_flags & _PR_UNIX_POLL_NVAL) {
out_flags |= PR_POLL_NVAL;
}
if (unixpd->out_flags & _PR_UNIX_POLL_HUP) {
out_flags |= PR_POLL_HUP;
}
}
unixpd++;
}
pd->out_flags = out_flags;
}
PR_DELETE(unixpds);
return ready;
}
/* LocalThreads */
# if defined(_PR_USE_POLL)
# define NativeThreads NativeThreadPoll
# else
# define NativeThreads NativeThreadSelect
# endif
PRInt32 _MD_pr_poll(PRPollDesc* pds, PRIntn npds, PRIntervalTime timeout) {
PRInt32 rv = 0;
PRThread* me = _PR_MD_CURRENT_THREAD();
if (_PR_PENDING_INTERRUPT(me)) {
me->flags &= ~_PR_INTERRUPT;
PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
return -1;
}
if (0 == npds) {
PR_Sleep(timeout);
}
else if (_PR_IS_NATIVE_THREAD(me)) {
rv = NativeThreads(pds, npds, timeout);
}
else {
rv = LocalThreads(pds, npds, timeout);
}
return rv;
}
/* _MD_pr_poll */
#endif /* defined(_PR_PTHREADS) */
/* uxpoll.c */
