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.27.2.6 and 1.42

version 1.27.2.6, 2014/06/03 20:39:54	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 - 2014	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	#ifdef HAVE_LIBPTHREAD
transit_task2ready(sched_task_t * __restrict t, sched_queue_t * __restrict q)	static void *
	_sched_threadWrapper(sched_task_t *t)
{	{
remove_task_from(t, q);	void *ret = NULL;
	sched_root_task_t *r;

t->task_type = taskREADY;	if (!t \|\| !TASK_ROOT(t))
insert_task_to(t, &(TASK_ROOT(t))->root_ready);	pthread_exit(ret);
	else
	r = (sched_root_task_t*) TASK_ROOT(t);

	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	/*
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
	*/

	/* notify parent, thread is ready for execution */
	pthread_testcancel();

	ret = schedCall(t);
	r->root_ret = ret;

	if (TASK_VAL(t)) {
	transit_task2unuse(t, &r->root_thread);
	TASK_VAL(t) = 0;
	}

	pthread_exit(ret);
}	}
	#endif

	#if defined(HAVE_LIBRT) && defined(HAVE_TIMER_CREATE) && \
	defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
	#if SUP_ENABLE == KQ_SUPPORT
	static void *
	_sched_rtcWrapper(sched_task_t *t)
	{
	sched_task_t *task;
	void *ret;

	if (!t \|\| !TASK_ROOT(t) \|\| !TASK_DATA(t))
	return NULL;
	else {
	task = (sched_task_t*) TASK_DATA(t);
	timer_delete((timer_t) TASK_DATLEN(t));
	}

	ret = schedCall(task);

	transit_task2unuse(task, &(TASK_ROOT(task))->root_rtc);
	return ret;
	}
	#else
	static void
	_sched_rtcSigWrapper(int sig, siginfo_t si, void uc)
	{
	sched_task_t *task;

	if (si && si->si_value.sival_ptr) {
	task = (sched_task_t*) si->si_value.sival_ptr;
	timer_delete((timer_t) TASK_FLAG(task));

	TASK_RET(task) = (intptr_t) schedCall(task);

	transit_task2unuse(task, &(TASK_ROOT(task))->root_rtc);
	}
	}
	#endif
	#endif

/*	/*
* sched_hook_init() - Default INIT hook	* sched_hook_init() - Default INIT hook
*	*
Line 85 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 113 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 133 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 158 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 174 sched_hook_cancel(void task, void arg __unused)	Line 237 sched_hook_cancel(void task, void arg __unused)
#endif	#endif
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
	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 \| EPOLLRDHUP);	} 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 212 sched_hook_cancel(void task, void arg __unused)	Line 280 sched_hook_cancel(void task, void arg __unused)
#endif	#endif
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
ee.data.fd = TASK_FD(t);	ee.data.fd = TASK_FD(t);
	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 \| EPOLLRDHUP;	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 224 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 253 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 271 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 287 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 302 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 */
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 327 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 336 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 354 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 367 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 395 sched_hook_cancel(void task, void arg __unused)	Line 449 sched_hook_cancel(void task, void arg __unused)
}	}
#endif	#endif
return NULL;	return NULL;
#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)	#if defined(HAVE_LIBRT) && defined(HAVE_TIMER_CREATE) && \
	defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
case taskRTC:	case taskRTC:
timer_delete((timer_t) TASK_FLAG(t));	timer_delete((timer_t) TASK_FLAG(t));
	#if SUP_ENABLE == KQ_SUPPORT
schedCancel((sched_task_t*) TASK_RET(t));	schedCancel((sched_task_t*) TASK_RET(t));
	#else
	/* check for multi subscribers */
	TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)
	if (TASK_DATA(tt) == TASK_DATA(t))
	flg++;

	/* restore signal */
	if (flg < 2)
	signal((intptr_t) TASK_DATA(t) + SIGRTMIN, SIG_DFL);
	#endif
return NULL;	return NULL;
#endif /* HAVE_TIMER_CREATE */	#endif /* HAVE_TIMER_CREATE */
default:	default:
Line 408 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 458 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 = { .events = EPOLLIN \| EPOLLPRI \| EPOLLRDHUP, .data.fd = 0 };	struct epoll_event ee = { 0 };
int flg = 0;	int flg = 0;
#endif	#endif

Line 477 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 489 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 (FD_ISSET(TASK_FD(t), &r->root_fds[0]))	if (!mask)
	mask = EPOLLIN \| EPOLLPRI;
	ee.data.fd = TASK_FD(t);
	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])) {
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;
}	}

ee.data.fd = TASK_FD(t);
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)
r->root_hooks.hook_exec.exception(r, NULL);	r->root_hooks.hook_exec.exception(r, NULL);
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 522 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 = { .events = EPOLLOUT, .data.fd = 0 };	struct epoll_event ee = { 0 };
int flg = 0;	int flg = 0;
#endif	#endif

Line 541 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 553 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.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 \| EPOLLRDHUP;	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.data.fd = TASK_FD(t);
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)
r->root_hooks.hook_exec.exception(r, NULL);	r->root_hooks.hook_exec.exception(r, NULL);
Line 568 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 621 sched_hook_alarm(void task, void arg __unused)	Line 733 sched_hook_alarm(void task, void arg __unused)
* sched_hook_node() - Default NODE hook	* sched_hook_node() - Default NODE hook
*	*
* @task = current task	* @task = current task
* @arg = unused	* @arg = if arg == 42 then waiting for all events
* return: <0 errors and 0 ok	* return: <0 errors and 0 ok
*/	*/
void *	void *
sched_hook_node(void task, void arg __unused)	sched_hook_node(void task, void arg)
{	{
#if SUP_ENABLE == KQ_SUPPORT	#if SUP_ENABLE == KQ_SUPPORT
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) (uintptr_t) arg;

if (!t \|\| !TASK_ROOT(t))	if (!t \|\| !TASK_ROOT(t))
return (void*) -1;	return (void*) -1;
Line 638 sched_hook_node(void task, void arg __unused)	Line 751 sched_hook_node(void task, void arg __unused)
#ifdef __NetBSD__	#ifdef __NetBSD__
EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD \| EV_CLEAR,	EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD \| EV_CLEAR,
NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \| NOTE_ATTRIB \|	NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \| NOTE_ATTRIB \|
NOTE_LINK \| NOTE_RENAME \| NOTE_REVOKE, 0, (intptr_t) TASK_FD(t));	NOTE_LINK \| NOTE_RENAME \| NOTE_REVOKE \| addflags, 0, (intptr_t) TASK_FD(t));
#else	#else
EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD \| EV_CLEAR,	EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD \| EV_CLEAR,
NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \| NOTE_ATTRIB \|	NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \| NOTE_ATTRIB \|
NOTE_LINK \| NOTE_RENAME \| NOTE_REVOKE, 0, (void*) TASK_FD(t));	NOTE_LINK \| NOTE_RENAME \| NOTE_REVOKE \| addflags, 0, (void*) TASK_FD(t));
#endif	#endif
if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
if (TASK_ROOT(t)->root_hooks.hook_exec.exception)	if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
Line 703 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 726 sched_hook_signal(void task, void arg __unused)	Line 838 sched_hook_signal(void task, void arg __unused)
LOGERR;	LOGERR;
return (void*) -1;	return (void*) -1;
}	}
#else	#endif
#if 0
sched_task_t *t = task;
struct sigaction sa;

memset(&sa, 0, sizeof sa);	pthread_mutex_lock(&TASK_ROOT(t)->root_sigmtx);
sigemptyset(&sa.sa_mask);	sigaddset(&TASK_ROOT(t)->root_sigset, TASK_VAL(t));
sa.sa_handler = _sched_sigHandler;	pthread_mutex_unlock(&TASK_ROOT(t)->root_sigmtx);
sa.sa_flags = SA_RESETHAND \| SA_RESTART;

if (sigaction(TASK_VAL(t), &sa, NULL) == -1) {
if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
TASK_ROOT(t)->root_hooks.hook_exec.exception(TASK_ROOT(t), NULL);
else
LOGERR;
return (void*) -1;
}
#endif /* 0 */
#endif
return NULL;	return NULL;
}	}

Line 800 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 899 fetch_hook_kevent_proceed(int en, struct kevent *res,
struct aiocb *acb;	struct aiocb *acb;
#ifdef EVFILT_LIO	#ifdef EVFILT_LIO
int l;	int l;
register int j;
off_t off;	off_t off;
struct aiocb **acbs;	struct aiocb **acbs;
struct iovec *iv;	struct iovec *iv;
Line 811 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:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
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_task_from(task, &r->root_read);

if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {	/* remove read handle */
if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {	remove_task_from(task, &r->root_read);
task->task_type = taskUNUSE;
insert_task_to(task, &r->root_unuse);	if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
} else {	if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
task->task_type = taskREADY;	task->task_type = taskUNUSE;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_unuse);
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
}	}
} else {	flg++;
task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);
}	}
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
case EVFILT_WRITE:	case EVFILT_WRITE:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
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_task_from(task, &r->root_write);

if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {	/* remove write handle */
if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {	remove_task_from(task, &r->root_write);
task->task_type = taskUNUSE;
insert_task_to(task, &r->root_unuse);	if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
} else {	if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
task->task_type = taskREADY;	task->task_type = taskUNUSE;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_unuse);
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
	} else {
	task->task_type = taskREADY;
	insert_task_to(task, &r->root_ready);
	}
}	}
} else {	flg++;
task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);
}	}
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
case EVFILT_TIMER:	case EVFILT_TIMER:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

	/* remove alarm handle */
	transit_task2ready(task, &r->root_alarm);
	}
flg++;	flg++;
TASK_RET(task) = res[i].data;
TASK_FLAG(task) = (u_long) res[i].fflags;
}	}
/* remove alarm handle */
transit_task2ready(task, &r->root_alarm);
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
case EVFILT_VNODE:	case EVFILT_VNODE:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

	/* remove node handle */
	transit_task2ready(task, &r->root_node);
	}
flg++;	flg++;
TASK_RET(task) = res[i].data;
TASK_FLAG(task) = (u_long) res[i].fflags;
}	}
/* remove node handle */
transit_task2ready(task, &r->root_node);
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
case EVFILT_PROC:	case EVFILT_PROC:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

	/* remove proc handle */
	transit_task2ready(task, &r->root_proc);
	}
flg++;	flg++;
TASK_RET(task) = res[i].data;
TASK_FLAG(task) = (u_long) res[i].fflags;
}	}
/* remove proc handle */
transit_task2ready(task, &r->root_proc);
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
case EVFILT_SIGNAL:	case EVFILT_SIGNAL:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

	/* remove signal handle */
	transit_task2ready(task, &r->root_signal);
	}
flg++;	flg++;
TASK_RET(task) = res[i].data;
TASK_FLAG(task) = (u_long) res[i].fflags;
}	}
/* remove signal handle */
transit_task2ready(task, &r->root_signal);
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
case EVFILT_AIO:	case EVFILT_AIO:
flg = 0;
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)) {
continue;	if (!flg) {
else {	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;
	if ((len = aio_return(acb)) != -1) {
	if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
	LOGERR;
	} else
	LOGERR;
	e_free(acb);
	TASK_DATLEN(task) = (u_long) len;
	TASK_FD(task) = fd;
	}
flg++;	flg++;
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;
if ((len = aio_return(acb)) != -1) {
if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
LOGERR;
} else
LOGERR;
free(acb);
TASK_DATLEN(task) = (u_long) len;
TASK_FD(task) = fd;
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
#ifdef EVFILT_LIO	#ifdef EVFILT_LIO
case EVFILT_LIO:	case EVFILT_LIO:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
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_lio);

iv = (struct iovec*) TASK_DATA(task);	/* remove user handle */
fd = acbs[0]->aio_fildes;	transit_task2ready(task, &r->root_lio);
off = acbs[0]->aio_offset;
for (j = len = 0; i < TASK_DATLEN(task); len += l, i++) {
if ((iv[i].iov_len = aio_return(acbs[i])) == -1)
l = 0;
else
l = iv[i].iov_len;
free(acbs[i]);
}
free(acbs);
TASK_DATLEN(task) = (u_long) len;
TASK_FD(task) = fd;

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

	if (lseek(fd, off + len, SEEK_CUR) == -1)
	LOGERR;
	}
	flg++;
	}
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
break;	break;
#endif /* EVFILT_LIO */	#endif /* EVFILT_LIO */
#endif /* AIO_SUPPORT */	#endif /* AIO_SUPPORT */
#ifdef EVFILT_USER	#ifdef EVFILT_USER
case EVFILT_USER:	case EVFILT_USER:
flg = 0;
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
	TASK_FLAG(task) = (u_long) res[i].fflags;

	/* remove user handle */
	transit_task2ready(task, &r->root_user);
	}
flg++;	flg++;
TASK_RET(task) = res[i].data;
TASK_FLAG(task) = (u_long) res[i].fflags;
}	}
/* remove user handle */
transit_task2ready(task, &r->root_user);
}	}
/* if match at least 2, don't remove resouce of event */
if (flg > 1)
evt->flags ^= evt->flags;
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 1042 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 task, tmp;	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 \| EPOLLET)) {	if (res[i].events & (EPOLLIN \| EPOLLPRI)) {
flg = 0;	task = NULL;
TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
if (TASK_FD(task) != evt->data.fd)	if (TASK_FD(t) == evt->data.fd) {
continue;	if (!task)
else {	task = t;
flg++;	rflg++;
FD_CLR(TASK_FD(task), &r->root_fds[0]);
TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));

evt->events &= ~(EPOLLIN \| EPOLLPRI \| EPOLLET \| EPOLLRDHUP);
if (FD_ISSET(TASK_FD(task), &r->root_fds[1])) {
ops = EPOLL_CTL_MOD;
evt->events \|= EPOLLOUT;
}
}	}
	}

	if (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 1082 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1155 fetch_hook_epoll_proceed(int en, struct epoll_event *r
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

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

evt->events &= ~EPOLLOUT;
if (FD_ISSET(TASK_FD(task), &r->root_fds[0])) {
ops = EPOLL_CTL_MOD;
evt->events \|= EPOLLIN \| EPOLLPRI \| EPOLLRDHUP;
}
}	}
	}

	if (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 1120 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1199 fetch_hook_epoll_proceed(int en, struct epoll_event *r
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

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

	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 1139 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 task, tmp;	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(task, &r->root_read, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
if (TASK_FD(task) != i)	if (TASK_FD(t) == i) {
continue;	if (!task)
else {	task = t;
flg++;	rflg++;
TASK_FLAG(task) = ioctl(TASK_FD(task),
FIONREAD, &TASK_RET(task));
}	}
	}

	if (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 1172 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1276 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

	/* remove resouce */
	if (rflg == 1) {
	FD_CLR(i, &r->root_fds[0]);
	FD_CLR(i, &r->root_fds[2]);
	}
}	}
/* if match equal to 1, remove resouce */
if (flg == 1)
FD_CLR(i, &r->root_fds[0]);
}	}

if (FD_ISSET(i, &wfd)) {	if (FD_ISSET(i, &wfd)) {
flg = 0;	task = NULL;
TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {	TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
if (TASK_FD(task) != i)	if (TASK_FD(t) == i) {
continue;	if (!task)
else {	task = t;
flg++;	wflg++;
TASK_FLAG(task) = ioctl(TASK_FD(task),
FIONWRITE, &TASK_RET(task));
}	}
	}

	if (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 1203 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1312 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
task->task_type = taskREADY;	task->task_type = taskREADY;
insert_task_to(task, &r->root_ready);	insert_task_to(task, &r->root_ready);
}	}

	/* remove resouce */
	if (wflg == 1)
	FD_CLR(i, &r->root_fds[1]);
}	}
/* if match equal to 1, remove resouce */
if (flg == 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 1231 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 evt[1], res[KQ_EVENTS];	struct kevent res[KQ_EVENTS];
struct timespec *timeout;	struct timespec *timeout;
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
struct epoll_event res[KQ_EVENTS];	struct epoll_event res[KQ_EVENTS];
Line 1257 sched_hook_fetch(void root, void arg __unused)	Line 1368 sched_hook_fetch(void root, void arg __unused)
return task;	return task;
}	}

	/* if present member of task, set NOWAIT */
	if (!TAILQ_FIRST(&r->root_task)) {
	/* timer tasks */
#ifdef TIMER_WITHOUT_SORT	#ifdef TIMER_WITHOUT_SORT
clock_gettime(CLOCK_MONOTONIC, &now);	clock_gettime(CLOCK_MONOTONIC, &now);

sched_timespecclear(&r->root_wait);	sched_timespecclear(&r->root_wait);
TAILQ_FOREACH(task, &r->root_timer, task_node) {	TAILQ_FOREACH(task, &r->root_timer, task_node) {
if (!sched_timespecisset(&r->root_wait))	if (!sched_timespecisset(&r->root_wait))
r->root_wait = TASK_TS(task);	r->root_wait = TASK_TS(task);
else if (sched_timespeccmp(&TASK_TS(task), &r->root_wait, -) < 0)	else if (sched_timespeccmp(&TASK_TS(task), &r->root_wait, -) < 0)
r->root_wait = TASK_TS(task);	r->root_wait = TASK_TS(task);
}	}

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)
} else {	/* don't wait for events. we have ready timer */
/* set wait INFTIM */	sched_timespecclear(&r->root_wait);
sched_timespecinf(&r->root_wait);	else
}	r->root_wait = mtmp;
	} else {
	/* set wait INFTIM */
	sched_timespecinf(&r->root_wait);
	}
#else /* ! TIMER_WITHOUT_SORT */	#else /* ! TIMER_WITHOUT_SORT */
if (!TAILQ_FIRST(&r->root_task) && (task = TAILQ_FIRST(&r->root_timer))) {	if ((task = TAILQ_FIRST(&r->root_timer))) {
clock_gettime(CLOCK_MONOTONIC, &now);	clock_gettime(CLOCK_MONOTONIC, &now);

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)
} else {	/* don't wait for events. we have ready timer */
/* set wait INFTIM */	sched_timespecclear(&r->root_wait);
sched_timespecinf(&r->root_wait);	else
}	r->root_wait = mtmp;
	} else {
	/* set wait INFTIM */
	sched_timespecinf(&r->root_wait);
	}
#endif /* TIMER_WITHOUT_SORT */	#endif /* TIMER_WITHOUT_SORT */
/* if present member of task, set NOWAIT */	} else /* no waiting for event, because we have ready task */
if (TAILQ_FIRST(&r->root_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 1323 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 */
Line 1430 sched_hook_condition(void root, void arg)	Line 1553 sched_hook_condition(void root, void arg)
* @arg = unused	* @arg = unused
* return: <0 errors and 0 ok	* return: <0 errors and 0 ok
*/	*/
#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
void *	void *
sched_hook_rtc(void task, void arg __unused)	sched_hook_rtc(void task, void arg __unused)
{	{
	#if defined(HAVE_LIBRT) && defined(HAVE_TIMER_CREATE) && \
	defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
sched_task_t sigt = NULL, t = task;	sched_task_t sigt = NULL, t = task;
struct itimerspec its;	struct itimerspec its;
struct sigevent evt;	struct sigevent evt;
timer_t tmr;	timer_t tmr;
	#if SUP_ENABLE != KQ_SUPPORT
	struct sigaction sa;
	#endif

if (!t \|\| !TASK_ROOT(t))	if (!t \|\| !TASK_ROOT(t))
return (void*) -1;	return (void*) -1;
Line 1445 sched_hook_rtc(void task, void arg __unused)	Line 1572 sched_hook_rtc(void task, void arg __unused)
memset(&evt, 0, sizeof evt);	memset(&evt, 0, sizeof evt);
evt.sigev_notify = SIGEV_SIGNAL;	evt.sigev_notify = SIGEV_SIGNAL;
evt.sigev_signo = (intptr_t) TASK_DATA(t) + SIGRTMIN;	evt.sigev_signo = (intptr_t) TASK_DATA(t) + SIGRTMIN;
evt.sigev_value.sival_ptr = TASK_DATA(t);	evt.sigev_value.sival_ptr = t;

if (timer_create(CLOCK_MONOTONIC, &evt, &tmr) == -1) {	if (timer_create(CLOCK_MONOTONIC, &evt, &tmr) == -1) {
if (TASK_ROOT(t)->root_hooks.hook_exec.exception)	if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
Line 1456 sched_hook_rtc(void task, void arg __unused)	Line 1583 sched_hook_rtc(void task, void arg __unused)
} else	} else
TASK_FLAG(t) = (u_long) tmr;	TASK_FLAG(t) = (u_long) tmr;

	#if SUP_ENABLE == KQ_SUPPORT
if (!(sigt = schedSignal(TASK_ROOT(t), _sched_rtcWrapper, TASK_ARG(t), evt.sigev_signo,	if (!(sigt = schedSignal(TASK_ROOT(t), _sched_rtcWrapper, TASK_ARG(t), evt.sigev_signo,
t, (size_t) tmr))) {	t, (size_t) tmr))) {
if (TASK_ROOT(t)->root_hooks.hook_exec.exception)	if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
Line 1466 sched_hook_rtc(void task, void arg __unused)	Line 1594 sched_hook_rtc(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
} else	} else
TASK_RET(t) = (uintptr_t) sigt;	TASK_RET(t) = (uintptr_t) sigt;
	#else
	memset(&sa, 0, sizeof sa);
	sigemptyset(&sa.sa_mask);
	sa.sa_sigaction = _sched_rtcSigWrapper;
	sa.sa_flags = SA_SIGINFO \| SA_RESTART;

	if (sigaction(evt.sigev_signo, &sa, NULL) == -1) {
	if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
	TASK_ROOT(t)->root_hooks.hook_exec.exception(TASK_ROOT(t), NULL);
	else
	LOGERR;
	timer_delete(tmr);
	return (void*) -1;
	}
	#endif

memset(&its, 0, sizeof its);	memset(&its, 0, sizeof its);
its.it_value.tv_sec = t->task_val.ts.tv_sec;	its.it_value.tv_sec = t->task_val.ts.tv_sec;
its.it_value.tv_nsec = t->task_val.ts.tv_nsec;	its.it_value.tv_nsec = t->task_val.ts.tv_nsec;
Line 1480 sched_hook_rtc(void task, void arg __unused)	Line 1623 sched_hook_rtc(void task, void arg __unused)
timer_delete(tmr);	timer_delete(tmr);
return (void*) -1;	return (void*) -1;
}	}
	#endif /* HAVE_TIMER_CREATE */
return NULL;	return NULL;
}	}
#endif /* HAVE_TIMER_CREATE */

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

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