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.35.4.1

version 1.27.2.6, 2014/06/03 20:39:54	version 1.35.4.1, 2022/10/17 22:38:26
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 - 2021
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 56 transit_task2ready(sched_task_t * __restrict t, sched_	Line 56 transit_task2ready(sched_task_t * __restrict t, sched_
insert_task_to(t, &(TASK_ROOT(t))->root_ready);	insert_task_to(t, &(TASK_ROOT(t))->root_ready);
}	}

	#ifdef HAVE_LIBPTHREAD
	static void *
	_sched_threadWrapper(sched_task_t *t)
	{
	void *ret = NULL;
	sched_root_task_t *r;

	if (!t \|\| !TASK_ROOT(t))
	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 174 sched_hook_cancel(void task, void arg __unused)	Line 245 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	else
ee.events \|= (EPOLLIN \| EPOLLPRI \| EPOLLRDHUP);	ee.events \|= EPOLLIN \| 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]);
Line 212 sched_hook_cancel(void task, void arg __unused)	Line 284 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 \| 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 303 sched_hook_cancel(void task, void arg __unused)	Line 376 sched_hook_cancel(void task, void arg __unused)
0, 0, (void*) TASK_VAL(t));	0, 0, (void*) TASK_VAL(t));
#endif	#endif
/* restore signal */	/* restore signal */
signal(TASK_VAL(t), SIG_DFL);	if (flg < 2)
	signal(TASK_VAL(t), SIG_DFL);
#endif	#endif
break;	break;
#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
Line 395 sched_hook_cancel(void task, void arg __unused)	Line 469 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 */
	flg = 0;
	TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)
	if (TASK_DATA(tt) != TASK_DATA(t))
	continue;
	else
	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 466 sched_hook_read(void task, void arg __unused)	Line 555 sched_hook_read(void task, void arg __unused)
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;
int flg = 0;	int flg = 0;
#endif	#endif

Line 489 sched_hook_read(void task, void arg __unused)	Line 578 sched_hook_read(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
}	}
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
	ee.data.fd = TASK_FD(t);
	ee.events = EPOLLIN \| 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;
if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {	if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {
Line 496 sched_hook_read(void task, void arg __unused)	Line 587 sched_hook_read(void task, void arg __unused)
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);
Line 530 sched_hook_write(void task, void arg __unused)	Line 620 sched_hook_write(void task, void arg __unused)
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;
int flg = 0;	int flg = 0;
#endif	#endif

Line 553 sched_hook_write(void task, void arg __unused)	Line 643 sched_hook_write(void task, void arg __unused)
return (void*) -1;	return (void*) -1;
}	}
#elif SUP_ENABLE == EP_SUPPORT	#elif SUP_ENABLE == EP_SUPPORT
	ee.data.fd = TASK_FD(t);
	ee.events = EPOLLOUT;

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 \| EPOLLPRI;
}	}
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.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 621 sched_hook_alarm(void task, void arg __unused)	Line 713 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 731 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 726 sched_hook_signal(void task, void arg __unused)	Line 819 sched_hook_signal(void task, void arg __unused)
LOGERR;	LOGERR;
return (void*) -1;	return (void*) -1;
}	}
#else
#if 0
sched_task_t *t = task;
struct sigaction sa;

memset(&sa, 0, sizeof sa);
sigemptyset(&sa.sa_mask);
sa.sa_handler = _sched_sigHandler;
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	#endif
return NULL;	return NULL;
}	}
Line 800 fetch_hook_kevent_proceed(int en, struct kevent *res,	Line 875 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 885 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;
	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;
	free(acbs[i]);
	}
	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 1044 fetch_hook_epoll_proceed(int en, struct epoll_event *r	Line 1095 fetch_hook_epoll_proceed(int en, struct epoll_event *r
{	{
register int i, flg;	register int i, flg;
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);

if (evt->events & (EPOLLIN \| EPOLLPRI \| EPOLLET)) {	if (evt->events & (EPOLLIN \| EPOLLPRI)) {
flg = 0;	flg = 0;
TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {	task = NULL;
if (TASK_FD(task) != evt->data.fd)	TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
continue;	if (TASK_FD(t) == evt->data.fd) {
else {	if (!flg)
	task = t;
flg++;	flg++;
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 (flg && 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 1130 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 (flg > 1)
ops = EPOLL_CTL_MOD;
}

if (evt->events & EPOLLOUT) {	evt->events ^= evt->events;
	if (FD_ISSET(evt->data.fd, &r->root_fds[1])) {
	ops = EPOLL_CTL_MOD;
	evt->events \|= EPOLLOUT;
	}
	if (flg > 1) {
	ops = EPOLL_CTL_MOD;
	evt->events \|= EPOLLIN \| EPOLLPRI;
	} else
	FD_CLR(evt->data.fd, &r->root_fds[0]);
	}
	} else if (evt->events & EPOLLOUT) {
flg = 0;	flg = 0;
TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {	task = NULL;
if (TASK_FD(task) != evt->data.fd)	TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
continue;	if (TASK_FD(t) == evt->data.fd) {
else {	if (!flg)
	task = t;
flg++;	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 (flg && 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 1171 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);
}	}

	evt->events ^= evt->events;
	if (FD_ISSET(evt->data.fd, &r->root_fds[0])) {
	ops = EPOLL_CTL_MOD;
	evt->events \|= EPOLLIN \| EPOLLPRI;
	}
	if (flg > 1) {
	ops = EPOLL_CTL_MOD;
	evt->events \|= EPOLLOUT;
	} else
	FD_CLR(evt->data.fd, &r->root_fds[1]);
}	}
if (flg > 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 (errno == EBADF) {
	epoll_ctl(r->root_kq, EPOLL_CTL_DEL, evt->data.fd, evt);
	schedCancelby(r, taskREAD, CRITERIA_FD,
	(void*) (uintptr_t) evt->data.fd, NULL);
	schedCancelby(r, taskWRITE, CRITERIA_FD,
	(void*) (uintptr_t) evt->data.fd, NULL);
	}
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
Line 1140 static inline void	Line 1207 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, flg;
sched_task_t task, tmp;	sched_task_t t, tmp, *task = NULL;

/* skip select check if return value from select is zero */	/* skip select check if return value from select is zero */
if (!en)	if (!en)
Line 1149 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w	Line 1216 fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
for (i = 0; i < r->root_kq; i++) {	for (i = 0; i < r->root_kq; i++) {
if (FD_ISSET(i, &rfd) \|\| FD_ISSET(i, &xfd)) {	if (FD_ISSET(i, &rfd) \|\| FD_ISSET(i, &xfd)) {
flg = 0;	flg = 0;
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 (!flg)
else {	task = t;
flg++;	flg++;
TASK_FLAG(task) = ioctl(TASK_FD(task),
FIONREAD, &TASK_RET(task));
}	}
	}

	if (flg && 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 1242 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);
}	}
}
/* if match equal to 1, remove resouce */
if (flg == 1)
FD_CLR(i, &r->root_fds[0]);
}

if (FD_ISSET(i, &wfd)) {	/* remove resouce */
	if (flg == 1)
	FD_CLR(i, &r->root_fds[0]);
	}
	} else if (FD_ISSET(i, &wfd)) {
flg = 0;	flg = 0;
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 (!flg)
else {	task = t;
flg++;	flg++;
TASK_FLAG(task) = ioctl(TASK_FD(task),
FIONWRITE, &TASK_RET(task));
}	}
	}

	if (flg && 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 1275 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 (flg == 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]);
}	}
}	}

Line 1233 sched_hook_fetch(void root, void arg __unused)	Line 1306 sched_hook_fetch(void root, void arg __unused)
sched_task_t task, tmp;	sched_task_t task, tmp;
struct timespec now, m, mtmp;	struct timespec now, m, mtmp;
#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 1330 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 (r->root_wait.tv_sec != -1 && r->root_wait.tv_nsec != -1) {
Line 1430 sched_hook_condition(void root, void arg)	Line 1505 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 1524 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 1535 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 1546 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 1575 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.35.4.1