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.28.2.3 and 1.40

version 1.28.2.3, 2015/07/02 22:43:30	version 1.40, 2023/02/25 15:55:01
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 - 2015	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 245 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 283 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 295 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 324 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 342 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 358 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 376 sched_hook_cancel(void task, void arg __unused)	Line 365 sched_hook_cancel(void task, void arg __unused)
/* restore signal */	/* restore signal */
if (flg < 2)	if (flg < 2)
signal(TASK_VAL(t), SIG_DFL);	signal(TASK_VAL(t), SIG_DFL);
	#else
	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);
	}
#endif	#endif
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 399 sched_hook_cancel(void task, void arg __unused)	Line 391 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 408 sched_hook_cancel(void task, void arg __unused)	Line 400 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 426 sched_hook_cancel(void task, void arg __unused)	Line 415 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 439 sched_hook_cancel(void task, void arg __unused)	Line 428 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 475 sched_hook_cancel(void task, void arg __unused)	Line 461 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 495 sched_hook_cancel(void task, void arg __unused)	Line 478 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 545 sched_hook_thread(void task, void arg)	Line 530 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 564 sched_hook_read(void task, void arg __unused)	Line 550 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 576 sched_hook_read(void task, void arg __unused)	Line 564 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 609 sched_hook_read(void task, void arg __unused)	Line 619 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 628 sched_hook_write(void task, void arg __unused)	Line 639 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 640 sched_hook_write(void task, void arg __unused)	Line 653 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 655 sched_hook_write(void task, void arg __unused)	Line 678 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 708 sched_hook_alarm(void task, void arg __unused)	Line 737 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 725 sched_hook_node(void task, void arg __unused)	Line 755 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 790 sched_hook_proc(void task, void arg __unused)	Line 820 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 };

Line 813 sched_hook_signal(void task, void arg __unused)	Line 844 sched_hook_signal(void task, void arg __unused)
LOGERR;	LOGERR;
return (void*) -1;	return (void*) -1;
}	}
	#else
	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);
#endif	#endif

return NULL;	return NULL;
}	}

Line 861 static inline void	Line 897 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 869 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 905 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 880 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 915 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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
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);
}	}
}	}
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
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);
}	}
}	}
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
TASK_FLAG(task) = (u_long) res[i].fflags;
	/* remove alarm handle */
	transit_task2ready(task, &r->root_alarm);
	}
	flg++;
}	}
/* remove alarm handle */
transit_task2ready(task, &r->root_alarm);
}	}
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
TASK_FLAG(task) = (u_long) res[i].fflags;
	/* remove node handle */
	transit_task2ready(task, &r->root_node);
	}
	flg++;
}	}
/* remove node handle */
transit_task2ready(task, &r->root_node);
}	}
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
TASK_FLAG(task) = (u_long) res[i].fflags;
	/* remove proc handle */
	transit_task2ready(task, &r->root_proc);
	}
	flg++;
}	}
/* remove proc handle */
transit_task2ready(task, &r->root_proc);
}	}
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
TASK_FLAG(task) = (u_long) res[i].fflags;
	/* remove signal handle */
	transit_task2ready(task, &r->root_signal);
	}
	flg++;
}	}
/* remove signal handle */
transit_task2ready(task, &r->root_signal);
}	}
break;	break;
#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
case EVFILT_AIO:	case EVFILT_AIO:
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_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
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)
LOGERR;	fd = acb->aio_fildes;
} else	if ((len = aio_return(acb)) != -1) {
LOGERR;	if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
free(acb);	LOGERR;
TASK_DATLEN(task) = (u_long) len;	} else
TASK_FD(task) = fd;	LOGERR;
	e_free(acb);
	TASK_DATLEN(task) = (u_long) len;
	TASK_FD(task) = fd;
	}
	flg++;
	}
}	}
break;	break;
#ifdef EVFILT_LIO	#ifdef EVFILT_LIO
case EVFILT_LIO:	case EVFILT_LIO:
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;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
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++;
	}
}	}
break;	break;
#endif /* EVFILT_LIO */	#endif /* EVFILT_LIO */
Line 1039 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1091 fetch_hook_kevent_proceed(int en, struct kevent *res,
#ifdef EVFILT_USER	#ifdef EVFILT_USER
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)) {
continue;	if (!flg) {
else {	TASK_RET(task) = res[i].data;
TASK_RET(task) = res[i].data;	TASK_FLAG(task) = (u_long) res[i].fflags;
TASK_FLAG(task) = (u_long) res[i].fflags;
	/* remove user handle */
	transit_task2ready(task, &r->root_user);
	}
	flg++;
}	}
/* remove user handle */
transit_task2ready(task, &r->root_user);
}	}
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 1066 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 1123 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 1106 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1161 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 1144 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1205 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 1163 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1239 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 1196 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1282 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]);
	}
}	}
/* remove resouce */
if (flg)
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 1227 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1318 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]);
}	}
/* remove resouce */
if (flg)
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 1255 sched_hook_fetch(void root, void arg __unused)	Line 1348 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 1281 sched_hook_fetch(void root, void arg __unused)	Line 1374 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;	r->root_wait = mtmp;
} else {	} else {
/* set wait INFTIM */	/* set wait INFTIM */
sched_timespecinf(&r->root_wait);	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;	r->root_wait = mtmp;
} else {	} else {
/* set wait INFTIM */	/* set wait INFTIM */
sched_timespecinf(&r->root_wait);	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 1347 sched_hook_fetch(void root, void arg __unused)	Line 1443 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 1454 sched_hook_condition(void root, void arg)	Line 1551 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_LIBRT) && 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;
Line 1524 sched_hook_rtc(void task, void arg __unused)	Line 1621 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.28.2.3
changed lines
	Added in v.1.40