[ashd.git] / lib / mtio-select.c

/*
    ashd - A Sane HTTP Daemon
    Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>

    This program 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 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    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, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <sys/select.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <log.h>
#include <utils.h>
#include <mt.h>
#include <mtio.h>

static struct blocker *blockers;
static int exitstatus;

struct blocker {
    struct blocker *n, *p;
    int fd;
    int ev;
    time_t to;
    struct muth *th;
};

int block(int fd, int ev, time_t to)
{
    struct blocker *bl;
    int rv;
    
    if(fd >= FD_SETSIZE) {
	flog(LOG_ERR, "tried to use more file descriptors than select() can handle: fd %i", fd);
	errno = EMFILE;
	return(-1);
    }
    omalloc(bl);
    bl->fd = fd;
    bl->ev = ev;
    if(to > 0)
	bl->to = time(NULL) + to;
    bl->th = current;
    bl->n = blockers;
    if(blockers)
	blockers->p = bl;
    blockers = bl;
    rv = yield();
    if(bl->n)
	bl->n->p = bl->p;
    if(bl->p)
	bl->p->n = bl->n;
    if(bl == blockers)
	blockers = bl->n;
    free(bl);
    return(rv);
}

int ioloop(void)
{
    int ret;
    fd_set rfds, wfds, efds;
    struct blocker *bl, *nbl;
    struct timeval toval;
    time_t now, timeout;
    int maxfd;
    int ev;
    
    exitstatus = 0;
    while(blockers != NULL) {
	FD_ZERO(&rfds);
	FD_ZERO(&wfds);
	FD_ZERO(&efds);
	maxfd = 0;
	now = time(NULL);
	timeout = 0;
	for(bl = blockers; bl; bl = bl->n) {
	    if(bl->ev & EV_READ)
		FD_SET(bl->fd, &rfds);
	    if(bl->ev & EV_WRITE)
		FD_SET(bl->fd, &wfds);
	    FD_SET(bl->fd, &efds);
	    if(bl->fd > maxfd)
		maxfd = bl->fd;
	    if((bl->to != 0) && ((timeout == 0) || (timeout > bl->to)))
		timeout = bl->to;
	}
	if(exitstatus)
	    return(exitstatus);
	toval.tv_sec = timeout - now;
	toval.tv_usec = 0;
	ret = select(maxfd + 1, &rfds, &wfds, &efds, timeout?(&toval):NULL);
	if(ret < 0) {
	    if(errno != EINTR) {
		flog(LOG_CRIT, "ioloop: select errored out: %s", strerror(errno));
		/* To avoid CPU hogging in case it's bad, which it
		 * probably is. */
		sleep(1);
	    }
	} else {
	    now = time(NULL);
	    for(bl = blockers; bl; bl = nbl) {
		nbl = bl->n;
		ev = 0;
		if(FD_ISSET(bl->fd, &rfds))
		    ev |= EV_READ;
		if(FD_ISSET(bl->fd, &wfds))
		    ev |= EV_WRITE;
		if(FD_ISSET(bl->fd, &efds))
		    ev = -1;
		if((ev < 0) || (ev & bl->ev))
		    resume(bl->th, ev);
		else if((bl->to != 0) && (bl->to <= now))
		    resume(bl->th, 0);
	    }
	}
    }
    return(0);
}

void exitioloop(int status)
{
    exitstatus = status;
}
Commit	Line	Data
a6cda4dd FT	1	/*
	2	ashd - A Sane HTTP Daemon
	3	Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <stdlib.h>
	20	#include <string.h>
3f3a9a68 FT	21	#include <time.h>
3f3a9a68 FT	22	#include <unistd.h>
a6cda4dd FT	23	#include <errno.h>
	24	#include <sys/select.h>
	25
	26	#ifdef HAVE_CONFIG_H
	27	#include <config.h>
	28	#endif
	29	#include <log.h>
	30	#include <utils.h>
	31	#include <mt.h>
	32	#include <mtio.h>
	33
	34	static struct blocker *blockers;
9d32586e	35	static int exitstatus;
a6cda4dd FT	36
	37	struct blocker {
	38	struct blocker n, p;
	39	int fd;
	40	int ev;
	41	time_t to;
	42	struct muth *th;
	43	};
	44
	45	int block(int fd, int ev, time_t to)
	46	{
	47	struct blocker *bl;
	48	int rv;
	49
886fff4d FT	50	if(fd >= FD_SETSIZE) {
	51	flog(LOG_ERR, "tried to use more file descriptors than select() can handle: fd %i", fd);
	52	errno = EMFILE;
	53	return(-1);
	54	}
a6cda4dd FT	55	omalloc(bl);
	56	bl->fd = fd;
	57	bl->ev = ev;
	58	if(to > 0)
	59	bl->to = time(NULL) + to;
	60	bl->th = current;
	61	bl->n = blockers;
	62	if(blockers)
	63	blockers->p = bl;
	64	blockers = bl;
	65	rv = yield();
	66	if(bl->n)
	67	bl->n->p = bl->p;
	68	if(bl->p)
	69	bl->p->n = bl->n;
	70	if(bl == blockers)
	71	blockers = bl->n;
	72	free(bl);
	73	return(rv);
	74	}
	75
9d32586e	76	int ioloop(void)
a6cda4dd FT	77	{
	78	int ret;
	79	fd_set rfds, wfds, efds;
	80	struct blocker bl, nbl;
	81	struct timeval toval;
	82	time_t now, timeout;
	83	int maxfd;
	84	int ev;
	85
9d32586e	86	exitstatus = 0;
a6cda4dd FT	87	while(blockers != NULL) {
	88	FD_ZERO(&rfds);
	89	FD_ZERO(&wfds);
	90	FD_ZERO(&efds);
	91	maxfd = 0;
	92	now = time(NULL);
	93	timeout = 0;
	94	for(bl = blockers; bl; bl = bl->n) {
	95	if(bl->ev & EV_READ)
	96	FD_SET(bl->fd, &rfds);
	97	if(bl->ev & EV_WRITE)
	98	FD_SET(bl->fd, &wfds);
	99	FD_SET(bl->fd, &efds);
	100	if(bl->fd > maxfd)
	101	maxfd = bl->fd;
	102	if((bl->to != 0) && ((timeout == 0) \|\| (timeout > bl->to)))
	103	timeout = bl->to;
	104	}
9d32586e FT	105	if(exitstatus)
9d32586e FT	106	return(exitstatus);
a6cda4dd FT	107	toval.tv_sec = timeout - now;
	108	toval.tv_usec = 0;
	109	ret = select(maxfd + 1, &rfds, &wfds, &efds, timeout?(&toval):NULL);
	110	if(ret < 0) {
	111	if(errno != EINTR) {
	112	flog(LOG_CRIT, "ioloop: select errored out: %s", strerror(errno));
	113	/* To avoid CPU hogging in case it's bad, which it
	114	* probably is. */
	115	sleep(1);
	116	}
9d32586e FT	117	} else {
	118	now = time(NULL);
	119	for(bl = blockers; bl; bl = nbl) {
	120	nbl = bl->n;
	121	ev = 0;
	122	if(FD_ISSET(bl->fd, &rfds))
	123	ev \|= EV_READ;
	124	if(FD_ISSET(bl->fd, &wfds))
	125	ev \|= EV_WRITE;
	126	if(FD_ISSET(bl->fd, &efds))
	127	ev = -1;
	128	if((ev < 0) \|\| (ev & bl->ev))
	129	resume(bl->th, ev);
	130	else if((bl->to != 0) && (bl->to <= now))
	131	resume(bl->th, 0);
	132	}
a6cda4dd FT	133	}
a6cda4dd FT	134	}
9d32586e FT	135	return(0);
	136	}
	137
	138	void exitioloop(int status)
	139	{
	140	exitstatus = status;
a6cda4dd	141	}