/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1994-2007, Dave Pare, Jeff Bailey, Thomas Ruschak,
- * Ken Stevens, Steve McClure
+ * Copyright (C) 1994-2015, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Ken Stevens, Steve McClure, Markus Armbruster
* Copyright (C) 1991-3 Stephen Crane
*
- * This program is free software; you can redistribute it and/or modify
+ * Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* ---
*
* sel.c: arrange to block on read/write file descriptors using lwp
- *
+ *
* Known contributors to this file:
* Dave Pare, 1994
- * Markus Armbruster, 2007
+ * Markus Armbruster, 2007-2013
+ * Ron Koenderink, 2009
*/
#include <config.h>
#include <errno.h>
-#include <sys/time.h>
+#include <sys/select.h>
#include <time.h>
-#include <unistd.h>
#include "lwp.h"
#include "lwpint.h"
#include "prototypes.h"
/* Map file descriptor to thread sleeping in lwpSleepFd() */
static struct lwpProc **LwpFdwait;
-/* Threads sleeping in lwpSleepUntil(), in no particular order */
+/*
+ * Threads sleeping until a wakeup time, in lwpSleepUntil() or
+ * lwpSleepFd(), in no particular order
+ */
static struct lwpQueue LwpDelayq;
/* The thread executing lwpSelect() */
-static struct lwpProc *LwpSelProc;
+static struct lwpProc *LwpSelProc;
void
lwpInitSelect(struct lwpProc *proc)
FD_ZERO(&LwpReadfds);
FD_ZERO(&LwpWritefds);
LwpFdwait = calloc(FD_SETSIZE, sizeof(struct lwpProc *));
- LwpDelayq.head = 0;
- LwpDelayq.tail = 0;
+ LwpDelayq.head = NULL;
+ LwpDelayq.tail = NULL;
LwpSelProc = proc;
}
-void
-lwpSleepFd(int fd, int mask)
+int
+lwpSleepFd(int fd, int mask, struct timeval *timeout)
{
lwpStatus(LwpCurrent, "sleeping on fd %d for %d", fd, mask);
- if (CANT_HAPPEN(fd > FD_SETSIZE))
- return;
- if (LwpFdwait[fd] != 0) {
+ if (CANT_HAPPEN(fd < 0 || fd >= FD_SETSIZE)) {
+ errno = EBADF;
+ return -1;
+ }
+ if (LwpFdwait[fd]) {
lwpStatus(LwpCurrent,
"multiple sleeps attempted on file descriptor %d", fd);
- return;
+ errno = EBADF;
+ return -1;
}
if (mask & LWP_FD_READ)
FD_SET(fd, &LwpReadfds);
if (mask & LWP_FD_WRITE)
FD_SET(fd, &LwpWritefds);
-
LwpNfds++;
- if (LwpMaxfd == 0 && LwpDelayq.head == 0) {
+ if (LwpMaxfd == 0 && !LwpDelayq.head) {
/* select process is sleeping until first waiter arrives */
lwpStatus(LwpCurrent, "going to resched fd %d", fd);
lwpReady(LwpSelProc);
}
lwpStatus(LwpCurrent, "going to wait on fd %d", fd);
+
+ if (timeout) {
+ LwpCurrent->runtime = time(NULL) + timeout->tv_sec +
+ (timeout->tv_usec > 0);
+ lwpAddTail(&LwpDelayq, LwpCurrent);
+ } else
+ LwpCurrent->runtime = (time_t)-1;
+
if (fd > LwpMaxfd)
LwpMaxfd = fd;
LwpFdwait[fd] = LwpCurrent;
LwpCurrent->fd = fd;
+ LwpCurrent->fd_ready = 0;
lwpReschedule();
+ return LwpCurrent->fd_ready != 0;
}
+/*
+ * Wake up PROC if it is sleeping in lwpSleepFd().
+ * Must be followed by lwpWakeupSleep() before the next lwpReschedule().
+ */
static void
lwpWakeupFd(struct lwpProc *proc)
{
- if (proc->fd < 0)
+ if (CANT_HAPPEN(proc->fd < 0 || proc->fd > LwpMaxfd))
return;
+ if (proc->runtime != (time_t)-1 && proc->runtime != 0) {
+ /* is in LwpDelayq; leave the job to lwpWakeupSleep() */
+ proc->runtime = (time_t)-1;
+ return;
+ }
lwpStatus(proc, "awakening; was sleeping on fd %d", proc->fd);
FD_CLR(proc->fd, &LwpReadfds);
FD_CLR(proc->fd, &LwpWritefds);
LwpNfds--;
- LwpFdwait[proc->fd] = 0;
+ LwpFdwait[proc->fd] = NULL;
proc->fd = -1;
lwpReady(proc);
}
+/*
+ * Wake up threads in LwpDelayq whose time has come.
+ */
void
lwpWakeupSleep(void)
{
if (LwpDelayq.head) {
now = time(NULL);
- save.tail = save.head = 0;
+ save.tail = save.head = NULL;
while (NULL != (proc = lwpGetFirst(&LwpDelayq))) {
if (now >= proc->runtime) {
lwpStatus(proc, "sleep done");
- lwpReady(proc);
+ if (proc->runtime != 0)
+ proc->runtime = (time_t)-1;
+ if (proc->fd >= 0)
+ lwpWakeupFd(proc);
+ else
+ lwpReady(proc);
} else {
lwpAddTail(&save, proc);
}
{
if (proc->fd >= 0)
lwpWakeupFd(proc);
- else if (proc->runtime != (time_t)-1) {
+ else if (proc->runtime != (time_t)-1)
proc->runtime = 0;
- lwpWakeupSleep();
- }
+ lwpWakeupSleep();
}
int
lwpStatus(LwpCurrent, "sleeping for %ld sec",
(long)(until - time(NULL)));
LwpCurrent->runtime = until;
- if (LwpMaxfd == 0 && LwpDelayq.head == 0) {
+ if (LwpMaxfd == 0 && !LwpDelayq.head) {
/* select process is sleeping until first waiter arrives */
lwpReady(LwpSelProc);
}
tv.tv_usec = 0;
if (LwpDelayq.head) {
time(&now);
- proc = LwpDelayq.head;
- for (; proc != 0; proc = proc->next) {
+ for (proc = LwpDelayq.head; proc; proc = proc->next) {
delta = proc->runtime - now;
if (delta < tv.tv_sec)
tv.tv_sec = delta;
if (tv.tv_sec < 0)
tv.tv_sec = 0;
}
- lwpStatus(us, "selecting; sleep %ld secs", tv.tv_sec);
+ lwpStatus(us, "selecting; sleep %ld secs", (long)tv.tv_sec);
memcpy(&readmask, &LwpReadfds, sizeof(fd_set));
memcpy(&writemask, &LwpWritefds, sizeof(fd_set));
continue;
}
- lwpWakeupSleep();
if (n > 0) {
/* file descriptor activity */
for (fd = 0; fd <= LwpMaxfd; fd++) {
- if (LwpFdwait[fd] == 0)
+ if (!LwpFdwait[fd])
continue;
if (FD_ISSET(fd, &readmask)) {
lwpStatus(LwpFdwait[fd], "input ready");
+ LwpFdwait[fd]->fd_ready = 1;
lwpWakeupFd(LwpFdwait[fd]);
continue;
}
if (FD_ISSET(fd, &writemask)) {
lwpStatus(LwpFdwait[fd], "output ready");
+ LwpFdwait[fd]->fd_ready = 1;
lwpWakeupFd(LwpFdwait[fd]);
continue;
}
}
}
+ lwpWakeupSleep();
lwpStatus(us, "fd dispatch completed");
lwpReady(LwpCurrent);
lwpReschedule();
}
- /*NOTREACHED*/
}
projects / empserver / blobdiff