libaitsched/src/hooks.c - diff

Return to hooks.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src

Diff for /libaitsched/src/hooks.c between versions 1.34 and 1.42

version 1.34, 2019/01/14 15:58:50	version 1.42, 2023/08/17 14:14:24
Line 12 terms:	Line 12 terms:
All of the documentation and software included in the ELWIX and AITNET	All of the documentation and software included in the ELWIX and AITNET
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

Copyright 2004 - 2018	Copyright 2004 - 2023
by Michael Pounov <misho@elwix.org>. All rights reserved.	by Michael Pounov <misho@elwix.org>. All rights reserved.

Redistribution and use in source and binary forms, with or without	Redistribution and use in source and binary forms, with or without
Line 47 SUCH DAMAGE.	Line 47 SUCH DAMAGE.
#include "hooks.h"	#include "hooks.h"


static inline void
transit_task2ready(sched_task_t * __restrict t, sched_queue_t * __restrict q)
{
remove_task_from(t, q);

t->task_type = taskREADY;
insert_task_to(t, &(TASK_ROOT(t))->root_ready);
}

#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
static void *	static void *
_sched_threadWrapper(sched_task_t *t)	_sched_threadWrapper(sched_task_t *t)
Line 156 sched_hook_init(void root, void arg __unused)	Line 147 sched_hook_init(void root, void arg __unused)
}	}
#else	#else
r->root_kq ^= r->root_kq;	r->root_kq ^= r->root_kq;
	#endif

FD_ZERO(&r->root_fds[0]);	FD_ZERO(&r->root_fds[0]);
FD_ZERO(&r->root_fds[1]);	FD_ZERO(&r->root_fds[1]);
#endif	FD_ZERO(&r->root_fds[2]);

return NULL;	return NULL;
}	}
Line 184 sched_hook_fini(void root, void arg __unused)	Line 177 sched_hook_fini(void root, void arg __unused)
r->root_kq = 0;	r->root_kq = 0;
}	}
#else	#else
FD_ZERO(&r->root_fds[1]);
FD_ZERO(&r->root_fds[0]);
r->root_kq ^= r->root_kq;	r->root_kq ^= r->root_kq;
#endif	#endif

	FD_ZERO(&r->root_fds[2]);
	FD_ZERO(&r->root_fds[1]);
	FD_ZERO(&r->root_fds[0]);

return NULL;	return NULL;
}	}

Line 204 sched_hook_cancel(void task, void arg __unused)	Line 199 sched_hook_cancel(void task, void arg __unused)
{	{
sched_task_t t = task, tmp, *tt;	sched_task_t t = task, tmp, *tt;
sched_root_task_t *r = NULL;	sched_root_task_t *r = NULL;
int flg;	int flg = 0;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
struct kevent chg[1];	struct kevent chg[1];
struct timespec timeout = { 0, 0 };	struct timespec timeout = { 0, 0 };
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
struct epoll_event ee = { .events = 0, .data.fd = 0 };	struct epoll_event ee = { .events = 0, .data.u64 = 0l };
#else	#else
register int i;	register int i;
#endif	#endif
Line 229 sched_hook_cancel(void task, void arg __unused)	Line 224 sched_hook_cancel(void task, void arg __unused)
switch (TASK_TYPE(t)) {	switch (TASK_TYPE(t)) {
case taskREAD:	case taskREAD:
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_read, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_read, task_node, tmp)
if (TASK_FD(tt) != TASK_FD(t))	if (TASK_FD(tt) == TASK_FD(t))
continue;
else
flg++;	flg++;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
#ifdef __NetBSD__	#ifdef __NetBSD__
Line 247 sched_hook_cancel(void task, void arg __unused)	Line 239 sched_hook_cancel(void task, void arg __unused)
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
ee.events ^= ee.events;	ee.events ^= ee.events;
if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))	if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))
ee.events = EPOLLOUT;	ee.events \|= EPOLLOUT;

if (flg < 2)	if (flg < 2) {
FD_CLR(TASK_FD(t), &r->root_fds[0]);	FD_CLR(TASK_FD(t), &r->root_fds[0]);
else	FD_CLR(TASK_FD(t), &r->root_fds[2]);
ee.events \|= EPOLLIN \| EPOLLPRI;	} else {
	if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))
	ee.events \|= EPOLLIN;
	if (FD_ISSET(TASK_FD(t), &r->root_fds[2]))
	ee.events \|= EPOLLPRI;
	}
#else	#else
if (flg < 2) {	if (flg < 2) {
FD_CLR(TASK_FD(t), &r->root_fds[0]);	FD_CLR(TASK_FD(t), &r->root_fds[0]);
	FD_CLR(TASK_FD(t), &r->root_fds[2]);

/* optimize select */	/* optimize select */
for (i = r->root_kq - 1; i > 2; i--)	for (i = r->root_kq - 1; i >= 0; i--)
if (FD_ISSET(i, &r->root_fds[0]) \|\| FD_ISSET(i, &r->root_fds[1]))	if (FD_ISSET(i, &r->root_fds[0]) \|\|
	FD_ISSET(i, &r->root_fds[1]) \|\|
	FD_ISSET(i, &r->root_fds[2]))
break;	break;
if (i > 2)	r->root_kq = i + 1;
r->root_kq = i + 1;
}	}
#endif	#endif
break;	break;
case taskWRITE:	case taskWRITE:
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_write, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_write, task_node, tmp)
if (TASK_FD(tt) != TASK_FD(t))	if (TASK_FD(tt) == TASK_FD(t))
continue;
else
flg++;	flg++;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
#ifdef __NetBSD__	#ifdef __NetBSD__
Line 286 sched_hook_cancel(void task, void arg __unused)	Line 282 sched_hook_cancel(void task, void arg __unused)
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
ee.events ^= ee.events;	ee.events ^= ee.events;
if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))	if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))
ee.events = EPOLLIN \| EPOLLPRI;	ee.events \|= EPOLLIN;
	if (FD_ISSET(TASK_FD(t), &r->root_fds[2]))
	ee.events \|= EPOLLPRI;

if (flg < 2)	if (flg < 2)
FD_CLR(TASK_FD(t), &r->root_fds[1]);	FD_CLR(TASK_FD(t), &r->root_fds[1]);
Line 297 sched_hook_cancel(void task, void arg __unused)	Line 295 sched_hook_cancel(void task, void arg __unused)
FD_CLR(TASK_FD(t), &r->root_fds[1]);	FD_CLR(TASK_FD(t), &r->root_fds[1]);

/* optimize select */	/* optimize select */
for (i = r->root_kq - 1; i > 2; i--)	for (i = r->root_kq - 1; i >= 0; i--)
if (FD_ISSET(i, &r->root_fds[0]) \|\| FD_ISSET(i, &r->root_fds[1]))	if (FD_ISSET(i, &r->root_fds[0]) \|\|
	FD_ISSET(i, &r->root_fds[1]) \|\|
	FD_ISSET(i, &r->root_fds[2]))
break;	break;
if (i > 2)	r->root_kq = i + 1;
r->root_kq = i + 1;
}	}
#endif	#endif
break;	break;
case taskALARM:	case taskALARM:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_alarm, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_alarm, task_node, tmp)
if (TASK_DATA(tt) != TASK_DATA(t))	if (TASK_DATA(tt) == TASK_DATA(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, flg < 2 ? EV_DELETE : 0,
Line 326 sched_hook_cancel(void task, void arg __unused)	Line 322 sched_hook_cancel(void task, void arg __unused)
case taskNODE:	case taskNODE:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_node, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_node, task_node, tmp)
if (TASK_FD(tt) != TASK_FD(t))	if (TASK_FD(tt) == TASK_FD(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, flg < 2 ? EV_DELETE : 0,
Line 344 sched_hook_cancel(void task, void arg __unused)	Line 337 sched_hook_cancel(void task, void arg __unused)
case taskPROC:	case taskPROC:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_proc, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_proc, task_node, tmp)
if (TASK_VAL(tt) != TASK_VAL(t))	if (TASK_VAL(tt) == TASK_VAL(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, flg < 2 ? EV_DELETE : 0,
Line 360 sched_hook_cancel(void task, void arg __unused)	Line 350 sched_hook_cancel(void task, void arg __unused)
#endif	#endif
break;	break;
case taskSIGNAL:	case taskSIGNAL:
#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_signal, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_signal, task_node, tmp)
if (TASK_VAL(tt) != TASK_VAL(t))	if (TASK_VAL(tt) == TASK_VAL(t))
continue;
else
flg++;	flg++;
	#if SUP_ENABLE == KQ_SUPPORT
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0,
0, 0, (intptr_t) TASK_VAL(t));	0, 0, (intptr_t) TASK_VAL(t));
Line 375 sched_hook_cancel(void task, void arg __unused)	Line 362 sched_hook_cancel(void task, void arg __unused)
EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0,
0, 0, (void*) TASK_VAL(t));	0, 0, (void*) TASK_VAL(t));
#endif	#endif
/* restore signal */
if (flg < 2)
signal(TASK_VAL(t), SIG_DFL);
#endif	#endif
	if (flg < 2) {
	pthread_mutex_lock(&TASK_ROOT(t)->root_sigmtx);
	sigdelset(&TASK_ROOT(t)->root_sigset, TASK_VAL(t));
	pthread_mutex_unlock(&TASK_ROOT(t)->root_sigmtx);
	}
break;	break;
#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
case taskAIO:	case taskAIO:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_aio, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_aio, task_node, tmp)
if (TASK_VAL(tt) != TASK_VAL(t))	if (TASK_VAL(tt) == TASK_VAL(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_AIO, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_AIO, flg < 2 ? EV_DELETE : 0,
Line 401 sched_hook_cancel(void task, void arg __unused)	Line 387 sched_hook_cancel(void task, void arg __unused)
if (acb) {	if (acb) {
if (aio_cancel(acb->aio_fildes, acb) == AIO_CANCELED)	if (aio_cancel(acb->aio_fildes, acb) == AIO_CANCELED)
aio_return(acb);	aio_return(acb);
free(acb);	e_free(acb);
TASK_VAL(t) = 0;	TASK_VAL(t) = 0;
}	}
#endif	#endif
Line 410 sched_hook_cancel(void task, void arg __unused)	Line 396 sched_hook_cancel(void task, void arg __unused)
case taskLIO:	case taskLIO:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_lio, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_lio, task_node, tmp)
if (TASK_VAL(tt) != TASK_VAL(t))	if (TASK_VAL(tt) == TASK_VAL(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_LIO, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_LIO, flg < 2 ? EV_DELETE : 0,
Line 428 sched_hook_cancel(void task, void arg __unused)	Line 411 sched_hook_cancel(void task, void arg __unused)
for (i = 0; i < TASK_DATLEN(t); i++) {	for (i = 0; i < TASK_DATLEN(t); i++) {
if (aio_cancel(acbs[i]->aio_fildes, acbs[i]) == AIO_CANCELED)	if (aio_cancel(acbs[i]->aio_fildes, acbs[i]) == AIO_CANCELED)
aio_return(acbs[i]);	aio_return(acbs[i]);
free(acbs[i]);	e_free(acbs[i]);
}	}
free(acbs);	e_free(acbs);
TASK_VAL(t) = 0;	TASK_VAL(t) = 0;
}	}
#endif	#endif
Line 441 sched_hook_cancel(void task, void arg __unused)	Line 424 sched_hook_cancel(void task, void arg __unused)
case taskUSER:	case taskUSER:
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_user, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_user, task_node, tmp)
if (TASK_VAL(tt) != TASK_VAL(t))	if (TASK_VAL(tt) == TASK_VAL(t))
continue;
else
flg++;	flg++;
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, flg < 2 ? EV_DELETE : 0,	EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, flg < 2 ? EV_DELETE : 0,
Line 477 sched_hook_cancel(void task, void arg __unused)	Line 457 sched_hook_cancel(void task, void arg __unused)
schedCancel((sched_task_t*) TASK_RET(t));	schedCancel((sched_task_t*) TASK_RET(t));
#else	#else
/* check for multi subscribers */	/* check for multi subscribers */
flg = 0;
TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)	TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)
if (TASK_DATA(tt) != TASK_DATA(t))	if (TASK_DATA(tt) == TASK_DATA(t))
continue;
else
flg++;	flg++;

/* restore signal */	/* restore signal */
Line 497 sched_hook_cancel(void task, void arg __unused)	Line 474 sched_hook_cancel(void task, void arg __unused)
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
kevent(r->root_kq, chg, 1, NULL, 0, &timeout);	kevent(r->root_kq, chg, 1, NULL, 0, &timeout);
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
epoll_ctl(r->root_kq, ee.events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, ee.data.fd, &ee);	if (TASK_TYPE(t) == taskREAD \|\| TASK_TYPE(t) == taskWRITE) {
	epoll_ctl(r->root_kq, ee.events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, ee.data.fd, &ee);
	}
#endif	#endif
return NULL;	return NULL;
}	}
Line 547 sched_hook_thread(void task, void arg)	Line 526 sched_hook_thread(void task, void arg)
* return: <0 errors and 0 ok	* return: <0 errors and 0 ok
*/	*/
void *	void *
sched_hook_read(void task, void arg __unused)	sched_hook_read(void task, void arg)
{	{
sched_task_t *t = task;	sched_task_t *t = task;
sched_root_task_t *r = NULL;	sched_root_task_t *r = NULL;
	uintptr_t mask = (uintptr_t) arg;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
struct kevent chg[1];	struct kevent chg[1];
struct timespec timeout = { 0, 0 };	struct timespec timeout = { 0, 0 };
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
struct epoll_event ee;	struct epoll_event ee = { 0 };
int flg = 0;	int flg = 0;
#endif	#endif

Line 566 sched_hook_read(void task, void arg __unused)	Line 546 sched_hook_read(void task, void arg __unused)

#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, (intptr_t) TASK_FD(t));	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD \| EV_CLEAR \| mask,
	0, 0, (intptr_t) TASK_FD(t));
#else	#else
EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, (void*) TASK_FD(t));	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD \| EV_CLEAR \| mask,
	0, 0, (void*) TASK_FD(t));
#endif	#endif
if (kevent(r->root_kq, chg, 1, NULL, 0, &timeout) == -1) {	if (kevent(r->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
if (r->root_hooks.hook_exec.exception)	if (r->root_hooks.hook_exec.exception)
Line 578 sched_hook_read(void task, void arg __unused)	Line 560 sched_hook_read(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
}	}
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
	if (!mask)
	mask = EPOLLIN \| EPOLLPRI;
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
ee.events = EPOLLIN \| EPOLLPRI;	ee.events = mask;
if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))	if (FD_ISSET(TASK_FD(t), &r->root_fds[2])) {
	flg \|= 4;
	ee.events \|= EPOLLPRI;
	}
	if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {
flg \|= 1;	flg \|= 1;
	ee.events \|= EPOLLIN;
	}
if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {	if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {
flg \|= 2;	flg \|= 2;
ee.events \|= EPOLLOUT;	ee.events \|= EPOLLOUT;
Line 593 sched_hook_read(void task, void arg __unused)	Line 583 sched_hook_read(void task, void arg __unused)
else	else
LOGERR;	LOGERR;
return (void*) -1;	return (void*) -1;
} else	} else {
FD_SET(TASK_FD(t), &r->root_fds[0]);	if (mask & EPOLLIN)
	FD_SET(TASK_FD(t), &r->root_fds[0]);
	if (mask & EPOLLPRI)
	FD_SET(TASK_FD(t), &r->root_fds[2]);
	}
#else	#else
FD_SET(TASK_FD(t), &r->root_fds[0]);	if (!mask) {
	FD_SET(TASK_FD(t), &r->root_fds[0]);
	FD_SET(TASK_FD(t), &r->root_fds[2]);
	} else {
	if (mask & 1)
	FD_SET(TASK_FD(t), &r->root_fds[0]);
	if (mask & 2)
	FD_SET(TASK_FD(t), &r->root_fds[2]);
	}

if (TASK_FD(t) >= r->root_kq)	if (TASK_FD(t) >= r->root_kq)
r->root_kq = TASK_FD(t) + 1;	r->root_kq = TASK_FD(t) + 1;
#endif	#endif
Line 612 sched_hook_read(void task, void arg __unused)	Line 615 sched_hook_read(void task, void arg __unused)
* return: <0 errors and 0 ok	* return: <0 errors and 0 ok
*/	*/
void *	void *
sched_hook_write(void task, void arg __unused)	sched_hook_write(void task, void arg)
{	{
sched_task_t *t = task;	sched_task_t *t = task;
sched_root_task_t *r = NULL;	sched_root_task_t *r = NULL;
	uintptr_t mask = (uintptr_t) arg;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
struct kevent chg[1];	struct kevent chg[1];
struct timespec timeout = { 0, 0 };	struct timespec timeout = { 0, 0 };
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
struct epoll_event ee;	struct epoll_event ee = { 0 };
int flg = 0;	int flg = 0;
#endif	#endif

Line 631 sched_hook_write(void task, void arg __unused)	Line 635 sched_hook_write(void task, void arg __unused)

#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD \| EV_CLEAR, 0, 0, (intptr_t) TASK_FD(t));	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD \| EV_CLEAR \| mask,
	0, 0, (intptr_t) TASK_FD(t));
#else	#else
EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD \| EV_CLEAR, 0, 0, (void*) TASK_FD(t));	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD \| EV_CLEAR \| mask,
	0, 0, (void*) TASK_FD(t));
#endif	#endif
if (kevent(r->root_kq, chg, 1, NULL, 0, &timeout) == -1) {	if (kevent(r->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
if (r->root_hooks.hook_exec.exception)	if (r->root_hooks.hook_exec.exception)
Line 643 sched_hook_write(void task, void arg __unused)	Line 649 sched_hook_write(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
}	}
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
	if (!mask)
	mask = EPOLLOUT;
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
ee.events = EPOLLOUT;	ee.events = mask;

	if (FD_ISSET(TASK_FD(t), &r->root_fds[2])) {
	flg \|= 4;
	ee.events \|= EPOLLPRI;
	}
if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {	if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {
flg \|= 1;	flg \|= 1;
ee.events \|= EPOLLIN \| EPOLLPRI;	ee.events \|= EPOLLIN;
}	}
if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))	if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {
flg \|= 2;	flg \|= 2;
	ee.events \|= EPOLLOUT;
	}

if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {	if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {
if (r->root_hooks.hook_exec.exception)	if (r->root_hooks.hook_exec.exception)
Line 660 sched_hook_write(void task, void arg __unused)	Line 674 sched_hook_write(void task, void arg __unused)
LOGERR;	LOGERR;
return (void*) -1;	return (void*) -1;
} else	} else
FD_SET(TASK_FD(t), &r->root_fds[1]);	if (mask & EPOLLOUT)
	FD_SET(TASK_FD(t), &r->root_fds[1]);
#else	#else
FD_SET(TASK_FD(t), &r->root_fds[1]);	if (!mask)
	FD_SET(TASK_FD(t), &r->root_fds[1]);
	else
	if (mask & 1)
	FD_SET(TASK_FD(t), &r->root_fds[1]);

if (TASK_FD(t) >= r->root_kq)	if (TASK_FD(t) >= r->root_kq)
r->root_kq = TASK_FD(t) + 1;	r->root_kq = TASK_FD(t) + 1;
#endif	#endif
Line 723 sched_hook_node(void task, void arg)	Line 743 sched_hook_node(void task, void arg)
sched_task_t *t = task;	sched_task_t *t = task;
struct kevent chg[1];	struct kevent chg[1];
struct timespec timeout = { 0, 0 };	struct timespec timeout = { 0, 0 };
u_int addflags = (u_int) arg;	u_int addflags = (u_int) (uintptr_t) arg;

if (!t \|\| !TASK_ROOT(t))	if (!t \|\| !TASK_ROOT(t))
return (void*) -1;	return (void*) -1;
Line 796 sched_hook_proc(void task, void arg __unused)	Line 816 sched_hook_proc(void task, void arg __unused)
void *	void *
sched_hook_signal(void task, void arg __unused)	sched_hook_signal(void task, void arg __unused)
{	{
#if SUP_ENABLE == KQ_SUPPORT
sched_task_t *t = task;	sched_task_t *t = task;
	#if SUP_ENABLE == KQ_SUPPORT
struct kevent chg[1];	struct kevent chg[1];
struct timespec timeout = { 0, 0 };	struct timespec timeout = { 0, 0 };
	#endif

if (!t \|\| !TASK_ROOT(t))	if (!t \|\| !TASK_ROOT(t))
return (void*) -1;	return (void*) -1;

/* ignore signal */	#if SUP_ENABLE == KQ_SUPPORT
signal(TASK_VAL(t), SIG_IGN);

#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_ADD \| EV_CLEAR, 0, 0, (intptr_t) TASK_VAL(t));	EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_ADD \| EV_CLEAR, 0, 0, (intptr_t) TASK_VAL(t));
#else	#else
Line 820 sched_hook_signal(void task, void arg __unused)	Line 839 sched_hook_signal(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
}	}
#endif	#endif

	pthread_mutex_lock(&TASK_ROOT(t)->root_sigmtx);
	sigaddset(&TASK_ROOT(t)->root_sigset, TASK_VAL(t));
	pthread_mutex_unlock(&TASK_ROOT(t)->root_sigmtx);

return NULL;	return NULL;
}	}

Line 867 static inline void	Line 891 static inline void
fetch_hook_kevent_proceed(int en, struct kevent res, sched_root_task_t r)	fetch_hook_kevent_proceed(int en, struct kevent res, sched_root_task_t r)
{	{
struct kevent evt[1];	struct kevent evt[1];
register int i;	register int i, flg;
sched_task_t task, tmp;	sched_task_t task, tmp;
struct timespec now = { 0, 0 };	struct timespec now = { 0, 0 };
#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
Line 885 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 909 fetch_hook_kevent_proceed(int en, struct kevent *res,
memcpy(evt, &res[i], sizeof evt);	memcpy(evt, &res[i], sizeof evt);
evt->flags = EV_DELETE;	evt->flags = EV_DELETE;
/* Put read/write task to ready queue */	/* Put read/write task to ready queue */
	flg = 0;
switch (res[i].filter) {	switch (res[i].filter) {
case EVFILT_READ:	case EVFILT_READ:
TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {
if (TASK_FD(task) == ((intptr_t) res[i].udata)) {	if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove read handle */	/* remove read handle */
remove_task_from(task, &r->root_read);	remove_task_from(task, &r->root_read);

if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {	if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {	if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
task->task_type = taskUNUSE;	task->task_type = taskUNUSE;
insert_task_to(task, &r->root_unuse);	insert_task_to(task, &r->root_unuse);
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
} else {	} else {
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}
} else {
task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);
}	}
break;	flg++;
}	}
}	}
break;	break;
case EVFILT_WRITE:	case EVFILT_WRITE:
TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {
if (TASK_FD(task) == ((intptr_t) res[i].udata)) {	if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove write handle */	/* remove write handle */
remove_task_from(task, &r->root_write);	remove_task_from(task, &r->root_write);

if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {	if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {	if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
task->task_type = taskUNUSE;	task->task_type = taskUNUSE;
insert_task_to(task, &r->root_unuse);	insert_task_to(task, &r->root_unuse);
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
} else {	} else {
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}
} else {
task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);
}	}
break;	flg++;
}	}
}	}
break;	break;
case EVFILT_TIMER:	case EVFILT_TIMER:
TAILQ_FOREACH_SAFE(task, &r->root_alarm, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_alarm, task_node, tmp) {
if ((uintptr_t) TASK_DATA(task) == ((uintptr_t) res[i].udata)) {	if ((uintptr_t) TASK_DATA(task) == ((uintptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove alarm handle */	/* remove alarm handle */
transit_task2ready(task, &r->root_alarm);	transit_task2ready(task, &r->root_alarm);
break;	}
	flg++;
}	}
}	}
break;	break;
case EVFILT_VNODE:	case EVFILT_VNODE:
TAILQ_FOREACH_SAFE(task, &r->root_node, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_node, task_node, tmp) {
if (TASK_FD(task) == ((intptr_t) res[i].udata)) {	if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove node handle */	/* remove node handle */
transit_task2ready(task, &r->root_node);	transit_task2ready(task, &r->root_node);
break;	}
	flg++;
}	}
}	}
break;	break;
case EVFILT_PROC:	case EVFILT_PROC:
TAILQ_FOREACH_SAFE(task, &r->root_proc, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_proc, task_node, tmp) {
if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {	if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove proc handle */	/* remove proc handle */
transit_task2ready(task, &r->root_proc);	transit_task2ready(task, &r->root_proc);
break;	}
	flg++;
}	}
}	}
break;	break;
case EVFILT_SIGNAL:	case EVFILT_SIGNAL:
TAILQ_FOREACH_SAFE(task, &r->root_signal, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_signal, task_node, tmp) {
if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {	if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove signal handle */	/* remove signal handle */
transit_task2ready(task, &r->root_signal);	transit_task2ready(task, &r->root_signal);
break;	}
	flg++;
}	}
}	}
break;	break;
Line 989 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1026 fetch_hook_kevent_proceed(int en, struct kevent *res,
TAILQ_FOREACH_SAFE(task, &r->root_aio, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_aio, task_node, tmp) {
acb = (struct aiocb*) TASK_VAL(task);	acb = (struct aiocb*) TASK_VAL(task);
if (acb == ((struct aiocb*) res[i].udata)) {	if (acb == ((struct aiocb*) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;
/* remove user handle */
transit_task2ready(task, &r->root_aio);

fd = acb->aio_fildes;	/* remove user handle */
if ((len = aio_return(acb)) != -1) {	transit_task2ready(task, &r->root_aio);
if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
	fd = acb->aio_fildes;
	if ((len = aio_return(acb)) != -1) {
	if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
	LOGERR;
	} else
LOGERR;	LOGERR;
} else	e_free(acb);
LOGERR;	TASK_DATLEN(task) = (u_long) len;
free(acb);	TASK_FD(task) = fd;
TASK_DATLEN(task) = (u_long) len;	}
TASK_FD(task) = fd;	flg++;
break;
}	}
}	}
break;	break;
Line 1013 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1052 fetch_hook_kevent_proceed(int en, struct kevent *res,
TAILQ_FOREACH_SAFE(task, &r->root_lio, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_lio, task_node, tmp) {
acbs = (struct aiocb**) TASK_VAL(task);	acbs = (struct aiocb**) TASK_VAL(task);
if (acbs == ((struct aiocb**) res[i].udata)) {	if (acbs == ((struct aiocb**) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove user handle */	/* remove user handle */
transit_task2ready(task, &r->root_lio);	transit_task2ready(task, &r->root_lio);

iv = (struct iovec*) TASK_DATA(task);	iv = (struct iovec*) TASK_DATA(task);
fd = acbs[0]->aio_fildes;	fd = acbs[0]->aio_fildes;
off = acbs[0]->aio_offset;	off = acbs[0]->aio_offset;
for (len = 0; i < TASK_DATLEN(task); len += l, i++) {	for (len = 0; i < TASK_DATLEN(task); len += l, i++) {
if ((iv[i].iov_len = aio_return(acbs[i])) == -1)	if ((iv[i].iov_len = aio_return(acbs[i])) == -1)
l = 0;	l = 0;
else	else
l = iv[i].iov_len;	l = iv[i].iov_len;
free(acbs[i]);	e_free(acbs[i]);
}	}
free(acbs);	e_free(acbs);
TASK_DATLEN(task) = (u_long) len;	TASK_DATLEN(task) = (u_long) len;
TASK_FD(task) = fd;	TASK_FD(task) = fd;

if (lseek(fd, off + len, SEEK_CUR) == -1)	if (lseek(fd, off + len, SEEK_CUR) == -1)
LOGERR;	LOGERR;
break;	}
	flg++;
}	}
}	}
break;	break;
Line 1045 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1086 fetch_hook_kevent_proceed(int en, struct kevent *res,
case EVFILT_USER:	case EVFILT_USER:
TAILQ_FOREACH_SAFE(task, &r->root_user, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &r->root_user, task_node, tmp) {
if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {	if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
TASK_RET(task) = res[i].data;	if (!flg) {
TASK_FLAG(task) = (u_long) res[i].fflags;	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

/* remove user handle */	/* remove user handle */
transit_task2ready(task, &r->root_user);	transit_task2ready(task, &r->root_user);
break;	}
	flg++;
}	}
}	}
break;	break;
#endif /* EVFILT_USER */	#endif /* EVFILT_USER */
}	}

	if (flg > 1)
	evt->flags &= ~EV_DELETE;

if (kevent(r->root_kq, evt, 1, NULL, 0, &now) == -1) {	if (kevent(r->root_kq, evt, 1, NULL, 0, &now) == -1) {
if (r->root_hooks.hook_exec.exception)	if (r->root_hooks.hook_exec.exception)
r->root_hooks.hook_exec.exception(r, NULL);	r->root_hooks.hook_exec.exception(r, NULL);
Line 1071 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1117 fetch_hook_kevent_proceed(int en, struct kevent *res,
static inline void	static inline void
fetch_hook_epoll_proceed(int en, struct epoll_event res, sched_root_task_t r)	fetch_hook_epoll_proceed(int en, struct epoll_event res, sched_root_task_t r)
{	{
register int i, flg;	register int i, rflg, wflg;
int ops = EPOLL_CTL_DEL;	int ops = EPOLL_CTL_DEL;
sched_task_t t, tmp, *task;	sched_task_t t, tmp, *task;
struct epoll_event evt[1];	struct epoll_event evt[1];

for (i = 0; i < en; i++) {	for (i = 0; i < en; i++) {
memcpy(evt, &res[i], sizeof evt);	memcpy(evt, &res[i], sizeof evt);
	evt->events ^= evt->events;
	rflg = wflg = 0;

if (evt->events & (EPOLLIN \| EPOLLPRI)) {	if (res[i].events & (EPOLLIN \| EPOLLPRI)) {
flg = 0;
task = NULL;	task = NULL;
TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
if (TASK_FD(t) == evt->data.fd) {	if (TASK_FD(t) == evt->data.fd) {
if (!flg)	if (!task)
task = t;	task = t;
flg++;	rflg++;
}	}
}	}

if (flg && task) {	if (task) {
TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));	TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));
/* remove read handle */	/* remove read handle */
remove_task_from(task, &r->root_read);	remove_task_from(task, &r->root_read);
Line 1109 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1156 fetch_hook_epoll_proceed(int en, struct epoll_event *r
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

evt->events ^= evt->events;	if (!(res[i].events & EPOLLOUT) && FD_ISSET(evt->data.fd, &r->root_fds[1])) {
if (FD_ISSET(evt->data.fd, &r->root_fds[1])) {
ops = EPOLL_CTL_MOD;
evt->events \|= EPOLLOUT;	evt->events \|= EPOLLOUT;
	wflg = 42;
}	}
if (flg > 1) {	if (rflg > 1) {
ops = EPOLL_CTL_MOD;	if (FD_ISSET(evt->data.fd, &r->root_fds[0]))
evt->events \|= EPOLLIN \| EPOLLPRI;	evt->events \|= EPOLLIN;
} else	if (FD_ISSET(evt->data.fd, &r->root_fds[2]))
	evt->events \|= EPOLLPRI;
	} else {
FD_CLR(evt->data.fd, &r->root_fds[0]);	FD_CLR(evt->data.fd, &r->root_fds[0]);
	FD_CLR(evt->data.fd, &r->root_fds[2]);
	}
}	}
} else if (evt->events & EPOLLOUT) {	}
flg = 0;	if (res[i].events & EPOLLOUT) {
task = NULL;	task = NULL;
TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
if (TASK_FD(t) == evt->data.fd) {	if (TASK_FD(t) == evt->data.fd) {
if (!flg)	if (!task)
task = t;	task = t;
flg++;	wflg++;
}	}
}	}

if (flg && task) {	if (task) {
TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));	TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));
/* remove write handle */	/* remove write handle */
remove_task_from(task, &r->root_write);	remove_task_from(task, &r->root_write);
Line 1150 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1200 fetch_hook_epoll_proceed(int en, struct epoll_event *r
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

evt->events ^= evt->events;	if (!(res[i].events & EPOLLIN) && FD_ISSET(evt->data.fd, &r->root_fds[0])) {
if (FD_ISSET(evt->data.fd, &r->root_fds[0])) {	evt->events \|= EPOLLIN;
ops = EPOLL_CTL_MOD;	rflg = 42;
evt->events \|= EPOLLIN \| EPOLLPRI;
}	}
if (flg > 1) {	if (!(res[i].events & EPOLLPRI) && FD_ISSET(evt->data.fd, &r->root_fds[2])) {
ops = EPOLL_CTL_MOD;	evt->events \|= EPOLLPRI;
	rflg = 42;
	}
	if (wflg > 1)
evt->events \|= EPOLLOUT;	evt->events \|= EPOLLOUT;
} else	else
FD_CLR(evt->data.fd, &r->root_fds[1]);	FD_CLR(evt->data.fd, &r->root_fds[1]);
}	}
}	}

	ops = EPOLL_CTL_DEL;
	if (rflg > 1 \|\| wflg > 1)
	ops = EPOLL_CTL_MOD;

if (epoll_ctl(r->root_kq, ops, evt->data.fd, evt) == -1) {	if (epoll_ctl(r->root_kq, ops, evt->data.fd, evt) == -1) {
if (r->root_hooks.hook_exec.exception) {	if (r->root_hooks.hook_exec.exception) {
r->root_hooks.hook_exec.exception(r, NULL);	r->root_hooks.hook_exec.exception(r, NULL);
Line 1177 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1233 fetch_hook_epoll_proceed(int en, struct epoll_event *r
static inline void	static inline void
fetch_hook_select_proceed(int en, fd_set rfd, fd_set wfd, fd_set xfd, sched_root_task_t *r)	fetch_hook_select_proceed(int en, fd_set rfd, fd_set wfd, fd_set xfd, sched_root_task_t *r)
{	{
register int i, flg;	register int i, rflg, wflg;
sched_task_t t, tmp, *task = NULL;	sched_task_t t, tmp, *task;

/* skip select check if return value from select is zero */	/* skip select check if return value from select is zero */
if (!en)	if (!en)
return;	return;

for (i = 0; i < r->root_kq; i++) {	for (i = 0; i < r->root_kq; i++) {
	if (!FD_ISSET(i, &r->root_fds[0]) &&
	!FD_ISSET(i, &r->root_fds[1]) &&
	!FD_ISSET(i, &r->root_fds[2]))
	continue;

	rflg = wflg = 0;

if (FD_ISSET(i, &rfd) \|\| FD_ISSET(i, &xfd)) {	if (FD_ISSET(i, &rfd) \|\| FD_ISSET(i, &xfd)) {
flg = 0;	task = NULL;
TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
if (TASK_FD(t) == i) {	if (TASK_FD(t) == i) {
if (!flg)	if (!task)
task = t;	task = t;
flg++;	rflg++;
}	}
}	}

if (flg && task) {	if (task) {
TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));	TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));

/* remove read handle */	/* remove read handle */
Line 1215 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1278 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
}	}

/* remove resouce */	/* remove resouce */
if (flg == 1)	if (rflg == 1) {
FD_CLR(i, &r->root_fds[0]);	FD_CLR(i, &r->root_fds[0]);
	FD_CLR(i, &r->root_fds[2]);
	}
}	}
} else if (FD_ISSET(i, &wfd)) {	}
flg = 0;	if (FD_ISSET(i, &wfd)) {
	task = NULL;
TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
if (TASK_FD(t) == i) {	if (TASK_FD(t) == i) {
if (!flg)	if (!task)
task = t;	task = t;
flg++;	wflg++;
}	}
}	}

if (flg && task) {	if (task) {
TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));	TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));

/* remove write handle */	/* remove write handle */
Line 1248 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1314 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
}	}

/* remove resouce */	/* remove resouce */
if (flg == 1)	if (wflg == 1)
FD_CLR(i, &r->root_fds[1]);	FD_CLR(i, &r->root_fds[1]);
}	}
}	}
}	}

/* optimize select */	/* optimize select */
for (i = r->root_kq - 1; i > 2; i--)	for (i = r->root_kq - 1; i >= 0; i--)
if (FD_ISSET(i, &r->root_fds[0]) \|\| FD_ISSET(i, &r->root_fds[1]))	if (FD_ISSET(i, &r->root_fds[0]) \|\|
	FD_ISSET(i, &r->root_fds[1]) \|\|
	FD_ISSET(i, &r->root_fds[2]))
break;	break;
if (i > 2)	r->root_kq = i + 1;
r->root_kq = i + 1;
}	}
#endif	#endif

Line 1275 sched_hook_fetch(void root, void arg __unused)	Line 1342 sched_hook_fetch(void root, void arg __unused)
{	{
sched_root_task_t *r = root;	sched_root_task_t *r = root;
sched_task_t task, tmp;	sched_task_t task, tmp;
struct timespec now, m, mtmp;	struct timespec now, m, mtmp, *tsmin;
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
struct kevent res[KQ_EVENTS];	struct kevent res[KQ_EVENTS];
struct timespec *timeout;	struct timespec *timeout;
Line 1318 sched_hook_fetch(void root, void arg __unused)	Line 1385 sched_hook_fetch(void root, void arg __unused)
if (TAILQ_FIRST(&r->root_timer)) {	if (TAILQ_FIRST(&r->root_timer)) {
m = r->root_wait;	m = r->root_wait;
sched_timespecsub(&m, &now, &mtmp);	sched_timespecsub(&m, &now, &mtmp);
r->root_wait = mtmp;	if (mtmp.tv_sec < 0 \|\| mtmp.tv_nsec < 0)
	/* don't wait for events. we have ready timer */
	sched_timespecclear(&r->root_wait);
	else
	r->root_wait = mtmp;
} else {	} else {
/* set wait INFTIM */	/* set wait INFTIM */
sched_timespecinf(&r->root_wait);	sched_timespecinf(&r->root_wait);
Line 1329 sched_hook_fetch(void root, void arg __unused)	Line 1400 sched_hook_fetch(void root, void arg __unused)

m = TASK_TS(task);	m = TASK_TS(task);
sched_timespecsub(&m, &now, &mtmp);	sched_timespecsub(&m, &now, &mtmp);
r->root_wait = mtmp;	if (mtmp.tv_sec < 0 \|\| mtmp.tv_nsec < 0)
	/* don't wait for events. we have ready timer */
	sched_timespecclear(&r->root_wait);
	else
	r->root_wait = mtmp;
} else {	} else {
/* set wait INFTIM */	/* set wait INFTIM */
sched_timespecinf(&r->root_wait);	sched_timespecinf(&r->root_wait);
Line 1338 sched_hook_fetch(void root, void arg __unused)	Line 1413 sched_hook_fetch(void root, void arg __unused)
} else /* no waiting for event, because we have ready task */	} else /* no waiting for event, because we have ready task */
sched_timespecclear(&r->root_wait);	sched_timespecclear(&r->root_wait);

if (r->root_wait.tv_sec != -1 && r->root_wait.tv_nsec != -1) {	if (!sched_timespecisinf(&r->root_wait)) {
	tsmin = sched_timespecmin(&r->root_wait, &r->root_poll);
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
timeout = &r->root_wait;	timeout = tsmin;
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
timeout = r->root_wait.tv_sec * 1000 + r->root_wait.tv_nsec / 1000000;	timeout = tsmin->tv_sec * 1000 + tsmin->tv_nsec / 1000000;
#else	#else
sched_timespec2val(&r->root_wait, &tv);	sched_timespec2val(tsmin, &tv);
timeout = &tv;	timeout = &tv;
#endif /* KQ_SUPPORT */	#endif /* KQ_SUPPORT */
} else if (sched_timespecisinf(&r->root_poll))	} else if (sched_timespecisinf(&r->root_poll))
Line 1369 sched_hook_fetch(void root, void arg __unused)	Line 1445 sched_hook_fetch(void root, void arg __unused)
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
if ((en = epoll_wait(r->root_kq, res, KQ_EVENTS, timeout)) == -1) {	if ((en = epoll_wait(r->root_kq, res, KQ_EVENTS, timeout)) == -1) {
#else	#else
rfd = xfd = r->root_fds[0];	xfd = r->root_fds[2];
	rfd = r->root_fds[0];
wfd = r->root_fds[1];	wfd = r->root_fds[1];
if ((en = select(r->root_kq, &rfd, &wfd, &xfd, timeout)) == -1) {	if ((en = select(r->root_kq, &rfd, &wfd, &xfd, timeout)) == -1) {
#endif /* KQ_SUPPORT */	#endif /* KQ_SUPPORT */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.34
changed lines
	Added in v.1.42