[irc/rqf/shadowircd.git] / libratbox / src / kqueue.c

/*
 *  ircd-ratbox: A slightly useful ircd.
 *  kqueue.c: FreeBSD kqueue compatible network routines.
 *
 *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
 *  Copyright (C) 1996-2002 Hybrid Development Team
 *  Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au>
 *  Copyright (C) 2002-2005 ircd-ratbox development team
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 *  USA
 *
 *  $Id: kqueue.c 26092 2008-09-19 15:13:52Z androsyn $
 */

#include <libratbox_config.h>
#include <ratbox_lib.h>
#include <commio-int.h>
#include <event-int.h>

#if defined(HAVE_SYS_EVENT_H) && (HAVE_KEVENT)

#include <sys/event.h>

/* jlemon goofed up and didn't add EV_SET until fbsd 4.3 */

#ifndef EV_SET
#define EV_SET(kevp, a, b, c, d, e, f) do {     \
        (kevp)->ident = (a);                    \
        (kevp)->filter = (b);                   \
        (kevp)->flags = (c);                    \
        (kevp)->fflags = (d);                   \
        (kevp)->data = (e);                     \
        (kevp)->udata = (f);                    \
} while(0)
#endif

#ifdef EVFILT_TIMER
#define KQUEUE_SCHED_EVENT
#endif


static void kq_update_events(rb_fde_t *, short, PF *);
static int kq;
static struct timespec zero_timespec;

static struct kevent *kqlst;	/* kevent buffer */
static struct kevent *kqout;	/* kevent output buffer */
static int kqmax;		/* max structs to buffer */
static int kqoff;		/* offset into the buffer */


int
rb_setup_fd_kqueue(rb_fde_t *F)
{
	return 0;
}

static void
kq_update_events(rb_fde_t *F, short filter, PF * handler)
{
	PF *cur_handler;
	int kep_flags;

	switch (filter)
	{
	case EVFILT_READ:
		cur_handler = F->read_handler;
		break;
	case EVFILT_WRITE:
		cur_handler = F->write_handler;
		break;
	default:
		/* XXX bad! -- adrian */
		return;
		break;
	}

	if((cur_handler == NULL && handler != NULL) || (cur_handler != NULL && handler == NULL))
	{
		struct kevent *kep;

		kep = kqlst + kqoff;

		if(handler != NULL)
		{
			kep_flags = EV_ADD | EV_ONESHOT;
		}
		else
		{
			kep_flags = EV_DELETE;
		}

		EV_SET(kep, (uintptr_t)F->fd, filter, kep_flags, 0, 0, (void *)F);

		if(++kqoff == kqmax)
		{
			int ret, i;

			/* Add them one at a time, because there may be
			 * already closed fds in it. The kernel will try
			 * to report invalid fds in the output; if there
			 * is no space, it silently stops processing the
			 * array at that point. We cannot give output space
			 * because that would also return events we cannot
			 * process at this point.
			 */
			for(i = 0; i < kqoff; i++)
			{
				ret = kevent(kq, kqlst + i, 1, NULL, 0, &zero_timespec);
				/* jdc -- someone needs to do error checking... */
				/* EBADF is normal here -- jilles */
				if(ret == -1 && errno != EBADF)
					rb_lib_log("kq_update_events(): kevent(): %s",
						   strerror(errno));
			}
			kqoff = 0;
		}
	}
}


/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
/* Public functions */


/*
 * rb_init_netio
 *
 * This is a needed exported function which will be called to initialise
 * the network loop code.
 */
int
rb_init_netio_kqueue(void)
{
	kq = kqueue();
	if(kq < 0)
	{
		return errno;
	}
	kqmax = getdtablesize();
	kqlst = rb_malloc(sizeof(struct kevent) * kqmax);
	kqout = rb_malloc(sizeof(struct kevent) * kqmax);
	rb_open(kq, RB_FD_UNKNOWN, "kqueue fd");
	zero_timespec.tv_sec = 0;
	zero_timespec.tv_nsec = 0;

	return 0;
}

/*
 * rb_setselect
 *
 * This is a needed exported function which will be called to register
 * and deregister interest in a pending IO state for a given FD.
 */
void
rb_setselect_kqueue(rb_fde_t *F, unsigned int type, PF * handler, void *client_data)
{
	lrb_assert(IsFDOpen(F));

	if(type & RB_SELECT_READ)
	{
		kq_update_events(F, EVFILT_READ, handler);
		F->read_handler = handler;
		F->read_data = client_data;
	}
	if(type & RB_SELECT_WRITE)
	{
		kq_update_events(F, EVFILT_WRITE, handler);
		F->write_handler = handler;
		F->write_data = client_data;
	}
}

/*
 * Check all connections for new connections and input data that is to be
 * processed. Also check for connections with data queued and whether we can
 * write it out.
 */

/*
 * rb_select
 *
 * Called to do the new-style IO, courtesy of squid (like most of this
 * new IO code). This routine handles the stuff we've hidden in
 * rb_setselect and fd_table[] and calls callbacks for IO ready
 * events.
 */

int
rb_select_kqueue(long delay)
{
	int num, i;
	struct timespec poll_time;
	struct timespec *pt;
	rb_fde_t *F;


	if(delay < 0)
	{
		pt = NULL;
	}
	else
	{
		pt = &poll_time;
		poll_time.tv_sec = delay / 1000;
		poll_time.tv_nsec = (delay % 1000) * 1000000;
	}

	for(;;)
	{
		num = kevent(kq, kqlst, kqoff, kqout, kqmax, pt);
		kqoff = 0;

		if(num >= 0)
			break;

		if(rb_ignore_errno(errno))
			break;

		rb_set_time();

		return RB_ERROR;

		/* NOTREACHED */
	}

	rb_set_time();

	if(num == 0)
		return RB_OK;	/* No error.. */

	for(i = 0; i < num; i++)
	{
		PF *hdl = NULL;

		if(kqout[i].flags & EV_ERROR)
		{
			errno = kqout[i].data;
			/* XXX error == bad! -- adrian */
			continue;	/* XXX! */
		}

		switch (kqout[i].filter)
		{

		case EVFILT_READ:
			F = kqout[i].udata;
			if((hdl = F->read_handler) != NULL)
			{
				F->read_handler = NULL;
				hdl(F, F->read_data);
			}

			break;

		case EVFILT_WRITE:
			F = kqout[i].udata;
			if((hdl = F->write_handler) != NULL)
			{
				F->write_handler = NULL;
				hdl(F, F->write_data);
			}
			break;
#if defined(EVFILT_TIMER)
		case EVFILT_TIMER:
			rb_run_event(kqout[i].udata);
			break;
#endif
		default:
			/* Bad! -- adrian */
			break;
		}
	}
	return RB_OK;
}

#if defined(KQUEUE_SCHED_EVENT)
static int can_do_event = 0;
int
rb_kqueue_supports_event(void)
{
	struct kevent kv;
	struct timespec ts;
	int xkq;

	if(can_do_event == 1)
		return 1;
	if(can_do_event == -1)
		return 0;

	xkq = kqueue();
	ts.tv_sec = 0;
	ts.tv_nsec = 1000;


	EV_SET(&kv, (uintptr_t)0x0, EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, 1, 0);
	if(kevent(xkq, &kv, 1, NULL, 0, NULL) < 0)
	{
		can_do_event = -1;
		close(xkq);
		return 0;
	}
	close(xkq);
	can_do_event = 1;
	return 1;
}

int
rb_kqueue_sched_event(struct ev_entry *event, int when)
{
	struct kevent kev;
	int kep_flags;

	kep_flags = EV_ADD;
	if(event->frequency == 0)
		kep_flags |= EV_ONESHOT;
	EV_SET(&kev, (uintptr_t)event, EVFILT_TIMER, kep_flags, 0, when * 1000, event);
	if(kevent(kq, &kev, 1, NULL, 0, NULL) < 0)
		return 0;
	return 1;
}

void
rb_kqueue_unsched_event(struct ev_entry *event)
{
	struct kevent kev;
	EV_SET(&kev, (uintptr_t)event, EVFILT_TIMER, EV_DELETE, 0, 0, event);
	kevent(kq, &kev, 1, NULL, 0, NULL);
}

void
rb_kqueue_init_event(void)
{
	return;
}
#endif /* KQUEUE_SCHED_EVENT */

#else /* kqueue not supported */
int
rb_init_netio_kqueue(void)
{
	errno = ENOSYS;
	return -1;
}

void
rb_setselect_kqueue(rb_fde_t *F, unsigned int type, PF * handler, void *client_data)
{
	errno = ENOSYS;
	return;
}

int
rb_select_kqueue(long delay)
{
	errno = ENOSYS;
	return -1;
}

int
rb_setup_fd_kqueue(rb_fde_t *F)
{
	errno = ENOSYS;
	return -1;
}

#endif

#if !defined(HAVE_KEVENT) || !defined(KQUEUE_SCHED_EVENT)
void
rb_kqueue_init_event(void)
{
	return;
}

int
rb_kqueue_sched_event(struct ev_entry *event, int when)
{
	errno = ENOSYS;
	return -1;
}

void
rb_kqueue_unsched_event(struct ev_entry *event)
{
	return;
}

int
rb_kqueue_supports_event(void)
{
	errno = ENOSYS;
	return 0;
}
#endif /* !HAVE_KEVENT || !KQUEUE_SCHED_EVENT */
Commit	Line	Data
b57f37fb WP	1	/*
	2	* ircd-ratbox: A slightly useful ircd.
	3	* kqueue.c: FreeBSD kqueue compatible network routines.
	4	*
	5	* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
	6	* Copyright (C) 1996-2002 Hybrid Development Team
	7	* Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au>
	8	* Copyright (C) 2002-2005 ircd-ratbox development team
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
	23	* USA
	24	*
94b4fbf9	25	* $Id: kqueue.c 26092 2008-09-19 15:13:52Z androsyn $
b57f37fb WP	26	*/
	27
	28	#include <libratbox_config.h>
	29	#include <ratbox_lib.h>
	30	#include <commio-int.h>
	31	#include <event-int.h>
	32
	33	#if defined(HAVE_SYS_EVENT_H) && (HAVE_KEVENT)
	34
	35	#include <sys/event.h>
	36
b57f37fb WP	37	/* jlemon goofed up and didn't add EV_SET until fbsd 4.3 */
	38
	39	#ifndef EV_SET
	40	#define EV_SET(kevp, a, b, c, d, e, f) do { \
	41	(kevp)->ident = (a); \
	42	(kevp)->filter = (b); \
	43	(kevp)->flags = (c); \
	44	(kevp)->fflags = (d); \
	45	(kevp)->data = (e); \
	46	(kevp)->udata = (f); \
	47	} while(0)
	48	#endif
	49
	50	#ifdef EVFILT_TIMER
	51	#define KQUEUE_SCHED_EVENT
	52	#endif
	53
	54
	55	static void kq_update_events(rb_fde_t , short, PF );
	56	static int kq;
	57	static struct timespec zero_timespec;
	58
	59	static struct kevent kqlst; / kevent buffer */
98686f18	60	static struct kevent kqout; / kevent output buffer */
b57f37fb WP	61	static int kqmax; /* max structs to buffer */
	62	static int kqoff; /* offset into the buffer */
	63
	64
	65	int
94b4fbf9	66	rb_setup_fd_kqueue(rb_fde_t *F)
b57f37fb WP	67	{
	68	return 0;
	69	}
	70
	71	static void
94b4fbf9	72	kq_update_events(rb_fde_t F, short filter, PF handler)
b57f37fb WP	73	{
	74	PF *cur_handler;
	75	int kep_flags;
	76
	77	switch (filter)
	78	{
	79	case EVFILT_READ:
	80	cur_handler = F->read_handler;
	81	break;
	82	case EVFILT_WRITE:
	83	cur_handler = F->write_handler;
	84	break;
	85	default:
	86	/* XXX bad! -- adrian */
	87	return;
	88	break;
	89	}
	90
	91	if((cur_handler == NULL && handler != NULL) \|\| (cur_handler != NULL && handler == NULL))
	92	{
	93	struct kevent *kep;
	94
	95	kep = kqlst + kqoff;
	96
	97	if(handler != NULL)
	98	{
c50bb62c	99	kep_flags = EV_ADD \| EV_ONESHOT;
b57f37fb WP	100	}
	101	else
	102	{
	103	kep_flags = EV_DELETE;
	104	}
	105
94b4fbf9	106	EV_SET(kep, (uintptr_t)F->fd, filter, kep_flags, 0, 0, (void *)F);
b57f37fb WP	107
	108	if(++kqoff == kqmax)
	109	{
98686f18 JT	110	int ret, i;
	111
	112	/* Add them one at a time, because there may be
	113	* already closed fds in it. The kernel will try
	114	* to report invalid fds in the output; if there
	115	* is no space, it silently stops processing the
	116	* array at that point. We cannot give output space
	117	* because that would also return events we cannot
	118	* process at this point.
	119	*/
94b4fbf9	120	for(i = 0; i < kqoff; i++)
b57f37fb	121	{
98686f18 JT	122	ret = kevent(kq, kqlst + i, 1, NULL, 0, &zero_timespec);
98686f18 JT	123	/* jdc -- someone needs to do error checking... */
e0bd36a5 JT	124	/* EBADF is normal here -- jilles */
e0bd36a5 JT	125	if(ret == -1 && errno != EBADF)
94b4fbf9 VY	126	rb_lib_log("kq_update_events(): kevent(): %s",
94b4fbf9 VY	127	strerror(errno));
b57f37fb WP	128	}
	129	kqoff = 0;
	130	}
	131	}
	132	}
	133
	134
	135
	136	/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
	137	/* Public functions */
	138
	139
	140	/*
	141	* rb_init_netio
	142	*
	143	* This is a needed exported function which will be called to initialise
	144	* the network loop code.
	145	*/
	146	int
	147	rb_init_netio_kqueue(void)
	148	{
	149	kq = kqueue();
	150	if(kq < 0)
	151	{
	152	return errno;
	153	}
	154	kqmax = getdtablesize();
	155	kqlst = rb_malloc(sizeof(struct kevent) * kqmax);
98686f18	156	kqout = rb_malloc(sizeof(struct kevent) * kqmax);
b57f37fb WP	157	rb_open(kq, RB_FD_UNKNOWN, "kqueue fd");
	158	zero_timespec.tv_sec = 0;
	159	zero_timespec.tv_nsec = 0;
	160
	161	return 0;
	162	}
	163
	164	/*
	165	* rb_setselect
	166	*
	167	* This is a needed exported function which will be called to register
	168	* and deregister interest in a pending IO state for a given FD.
	169	*/
	170	void
94b4fbf9	171	rb_setselect_kqueue(rb_fde_t F, unsigned int type, PF handler, void *client_data)
b57f37fb WP	172	{
	173	lrb_assert(IsFDOpen(F));
	174
	175	if(type & RB_SELECT_READ)
	176	{
	177	kq_update_events(F, EVFILT_READ, handler);
	178	F->read_handler = handler;
	179	F->read_data = client_data;
	180	}
	181	if(type & RB_SELECT_WRITE)
	182	{
	183	kq_update_events(F, EVFILT_WRITE, handler);
	184	F->write_handler = handler;
	185	F->write_data = client_data;
	186	}
	187	}
	188
	189	/*
	190	* Check all connections for new connections and input data that is to be
	191	* processed. Also check for connections with data queued and whether we can
	192	* write it out.
	193	*/
	194
	195	/*
	196	* rb_select
	197	*
	198	* Called to do the new-style IO, courtesy of squid (like most of this
	199	* new IO code). This routine handles the stuff we've hidden in
	200	* rb_setselect and fd_table[] and calls callbacks for IO ready
	201	* events.
	202	*/
	203
	204	int
	205	rb_select_kqueue(long delay)
	206	{
	207	int num, i;
b57f37fb WP	208	struct timespec poll_time;
	209	struct timespec *pt;
	210	rb_fde_t *F;
	211
	212
94b4fbf9 VY	213	if(delay < 0)
94b4fbf9 VY	214	{
b57f37fb WP	215	pt = NULL;
b57f37fb WP	216	}
94b4fbf9 VY	217	else
94b4fbf9 VY	218	{
b57f37fb WP	219	pt = &poll_time;
	220	poll_time.tv_sec = delay / 1000;
	221	poll_time.tv_nsec = (delay % 1000) * 1000000;
	222	}
	223
94b4fbf9	224	for(;;)
b57f37fb	225	{
98686f18	226	num = kevent(kq, kqlst, kqoff, kqout, kqmax, pt);
b57f37fb WP	227	kqoff = 0;
	228
	229	if(num >= 0)
	230	break;
	231
	232	if(rb_ignore_errno(errno))
	233	break;
	234
	235	rb_set_time();
	236
	237	return RB_ERROR;
	238
	239	/* NOTREACHED */
	240	}
	241
	242	rb_set_time();
	243
	244	if(num == 0)
	245	return RB_OK; /* No error.. */
	246
94b4fbf9	247	for(i = 0; i < num; i++)
b57f37fb WP	248	{
	249	PF *hdl = NULL;
	250
98686f18	251	if(kqout[i].flags & EV_ERROR)
b57f37fb	252	{
98686f18	253	errno = kqout[i].data;
b57f37fb WP	254	/* XXX error == bad! -- adrian */
	255	continue; /* XXX! */
	256	}
	257
98686f18	258	switch (kqout[i].filter)
b57f37fb WP	259	{
	260
	261	case EVFILT_READ:
98686f18	262	F = kqout[i].udata;
b57f37fb WP	263	if((hdl = F->read_handler) != NULL)
	264	{
	265	F->read_handler = NULL;
	266	hdl(F, F->read_data);
	267	}
	268
	269	break;
	270
	271	case EVFILT_WRITE:
98686f18	272	F = kqout[i].udata;
b57f37fb WP	273	if((hdl = F->write_handler) != NULL)
	274	{
	275	F->write_handler = NULL;
	276	hdl(F, F->write_data);
	277	}
	278	break;
	279	#if defined(EVFILT_TIMER)
	280	case EVFILT_TIMER:
98686f18	281	rb_run_event(kqout[i].udata);
b57f37fb WP	282	break;
	283	#endif
	284	default:
	285	/* Bad! -- adrian */
	286	break;
	287	}
	288	}
	289	return RB_OK;
	290	}
033be687 VY	291
033be687 VY	292	#if defined(KQUEUE_SCHED_EVENT)
b57f37fb WP	293	static int can_do_event = 0;
	294	int
	295	rb_kqueue_supports_event(void)
	296	{
	297	struct kevent kv;
	298	struct timespec ts;
	299	int xkq;
	300
	301	if(can_do_event == 1)
	302	return 1;
	303	if(can_do_event == -1)
	304	return 0;
	305
	306	xkq = kqueue();
	307	ts.tv_sec = 0;
	308	ts.tv_nsec = 1000;
	309
	310
94b4fbf9	311	EV_SET(&kv, (uintptr_t)0x0, EVFILT_TIMER, EV_ADD \| EV_ONESHOT, 0, 1, 0);
b57f37fb WP	312	if(kevent(xkq, &kv, 1, NULL, 0, NULL) < 0)
	313	{
	314	can_do_event = -1;
	315	close(xkq);
	316	return 0;
	317	}
	318	close(xkq);
	319	can_do_event = 1;
	320	return 1;
	321	}
	322
	323	int
	324	rb_kqueue_sched_event(struct ev_entry *event, int when)
	325	{
	326	struct kevent kev;
	327	int kep_flags;
	328
	329	kep_flags = EV_ADD;
	330	if(event->frequency == 0)
	331	kep_flags \|= EV_ONESHOT;
94b4fbf9	332	EV_SET(&kev, (uintptr_t)event, EVFILT_TIMER, kep_flags, 0, when * 1000, event);
b57f37fb	333	if(kevent(kq, &kev, 1, NULL, 0, NULL) < 0)
94b4fbf9	334	return 0;
b57f37fb WP	335	return 1;
	336	}
	337
	338	void
	339	rb_kqueue_unsched_event(struct ev_entry *event)
	340	{
	341	struct kevent kev;
94b4fbf9	342	EV_SET(&kev, (uintptr_t)event, EVFILT_TIMER, EV_DELETE, 0, 0, event);
b57f37fb WP	343	kevent(kq, &kev, 1, NULL, 0, NULL);
	344	}
	345
	346	void
	347	rb_kqueue_init_event(void)
	348	{
	349	return;
	350	}
033be687	351	#endif /* KQUEUE_SCHED_EVENT */
b57f37fb WP	352
	353	#else /* kqueue not supported */
	354	int
	355	rb_init_netio_kqueue(void)
	356	{
	357	errno = ENOSYS;
	358	return -1;
	359	}
	360
	361	void
94b4fbf9	362	rb_setselect_kqueue(rb_fde_t F, unsigned int type, PF handler, void *client_data)
b57f37fb WP	363	{
	364	errno = ENOSYS;
	365	return;
	366	}
	367
	368	int
	369	rb_select_kqueue(long delay)
	370	{
	371	errno = ENOSYS;
	372	return -1;
	373	}
	374
	375	int
94b4fbf9	376	rb_setup_fd_kqueue(rb_fde_t *F)
b57f37fb WP	377	{
	378	errno = ENOSYS;
	379	return -1;
	380	}
	381
	382	#endif
	383
	384	#if !defined(HAVE_KEVENT) \|\| !defined(KQUEUE_SCHED_EVENT)
	385	void
	386	rb_kqueue_init_event(void)
	387	{
	388	return;
	389	}
	390
	391	int
	392	rb_kqueue_sched_event(struct ev_entry *event, int when)
	393	{
	394	errno = ENOSYS;
	395	return -1;
	396	}
	397
	398	void
	399	rb_kqueue_unsched_event(struct ev_entry *event)
	400	{
	401	return;
	402	}
	403
	404	int
	405	rb_kqueue_supports_event(void)
	406	{
	407	errno = ENOSYS;
	408	return 0;
	409	}
	410	#endif /* !HAVE_KEVENT \|\| !KQUEUE_SCHED_EVENT */