--- libaitsched/src/hooks.c	2012/05/10 14:44:22	1.5.2.3
+++ libaitsched/src/hooks.c	2012/06/29 13:39:54	1.8.2.1
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: hooks.c,v 1.5.2.3 2012/05/10 14:44:22 misho Exp $
+* $Id: hooks.c,v 1.8.2.1 2012/06/29 13:39:54 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -118,7 +118,6 @@ sched_hook_cancel(void *task, void *arg __unused)
 #else
 			EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_DELETE, 0, 0, (void*) TASK_FD(t));
 #endif
-			kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout);
 			break;
 		case taskWRITE:
 #ifdef __NetBSD__
@@ -126,12 +125,51 @@ sched_hook_cancel(void *task, void *arg __unused)
 #else
 			EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_DELETE, 0, 0, (void*) TASK_FD(t));
 #endif
-			kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout);
 			break;
-		default:
+		case taskALARM:
+#ifdef __NetBSD__
+			EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, EV_DELETE, 
+					0, 0, (intptr_t) TASK_DATA(t));
+#else
+			EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, EV_DELETE, 
+					0, 0, (void*) TASK_DATA(t));
+#endif
 			break;
+		case taskNODE:
+#ifdef __NetBSD__
+			EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_DELETE, 0, 0, (intptr_t) TASK_FD(t));
+#else
+			EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_DELETE, 0, 0, (void*) TASK_FD(t));
+#endif
+			break;
+		case taskPROC:
+#ifdef __NetBSD__
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, EV_DELETE, 0, 0, (intptr_t) TASK_VAL(t));
+#else
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, EV_DELETE, 0, 0, (void*) TASK_VAL(t));
+#endif
+			break;
+		case taskSIGNAL:
+#ifdef __NetBSD__
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_DELETE, 0, 0, (intptr_t) TASK_VAL(t));
+#else
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_DELETE, 0, 0, (void*) TASK_VAL(t));
+#endif
+			break;
+#ifdef EVFILT_USER
+		case taskUSER:
+#ifdef __NetBSD__
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, EV_DELETE, 0, 0, (intptr_t) TASK_VAL(t));
+#else
+			EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, EV_DELETE, 0, 0, (void*) TASK_VAL(t));
+#endif
+#endif
+			break;
+		default:
+			return NULL;
 	}
 
+	kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout);
 	return NULL;
 }
 
@@ -153,9 +191,9 @@ sched_hook_read(void *task, void *arg __unused)
 		return (void*) -1;
 
 #ifdef __NetBSD__
-	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD, 0, 0, (intptr_t) TASK_FD(t));
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, (intptr_t) TASK_FD(t));
 #else
-	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD, 0, 0, (void*) TASK_FD(t));
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, (void*) TASK_FD(t));
 #endif
 	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
 		if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
@@ -186,9 +224,9 @@ sched_hook_write(void *task, void *arg __unused)
 		return (void*) -1;
 
 #ifdef __NetBSD__
-	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD, 0, 0, (intptr_t) TASK_FD(t));
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, (intptr_t) TASK_FD(t));
 #else
-	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD, 0, 0, (void*) TASK_FD(t));
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, (void*) TASK_FD(t));
 #endif
 	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
 		if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
@@ -202,6 +240,185 @@ sched_hook_write(void *task, void *arg __unused)
 }
 
 /*
+ * sched_hook_alarm() - Default ALARM hook
+ *
+ * @task = current task
+ * @arg = unused
+ * return: <0 errors and 0 ok
+ */
+void *
+sched_hook_alarm(void *task, void *arg __unused)
+{
+	sched_task_t *t = task;
+	struct kevent chg[1];
+	struct timespec timeout = { 0, 0 };
+
+	if (!t || !TASK_ROOT(t))
+		return (void*) -1;
+
+#ifdef __NetBSD__
+	EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, 
+			t->task_val.ts.tv_sec * 1000 + t->task_val.ts.tv_nsec / 1000000, 
+			(intptr_t) TASK_DATA(t));
+#else
+	EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, 
+			t->task_val.ts.tv_sec * 1000 + t->task_val.ts.tv_nsec / 1000000, 
+			(void*) TASK_DATA(t));
+#endif
+	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -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;
+	}
+
+	return NULL;
+}
+
+/*
+ * sched_hook_node() - Default NODE hook
+ *
+ * @task = current task
+ * @arg = unused
+ * return: <0 errors and 0 ok
+ */
+void *
+sched_hook_node(void *task, void *arg __unused)
+{
+	sched_task_t *t = task;
+	struct kevent chg[1];
+	struct timespec timeout = { 0, 0 };
+
+	if (!t || !TASK_ROOT(t))
+		return (void*) -1;
+
+#ifdef __NetBSD__
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR, 
+			NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | 
+			NOTE_LINK | NOTE_RENAME | NOTE_REVOKE, 0, (intptr_t) TASK_FD(t));
+#else
+	EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR, 
+			NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | 
+			NOTE_LINK | NOTE_RENAME | NOTE_REVOKE, 0, (void*) TASK_FD(t));
+#endif
+	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -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;
+	}
+
+	return NULL;
+}
+
+/*
+ * sched_hook_proc() - Default PROC hook
+ *
+ * @task = current task
+ * @arg = unused
+ * return: <0 errors and 0 ok
+ */
+void *
+sched_hook_proc(void *task, void *arg __unused)
+{
+	sched_task_t *t = task;
+	struct kevent chg[1];
+	struct timespec timeout = { 0, 0 };
+
+	if (!t || !TASK_ROOT(t))
+		return (void*) -1;
+
+#ifdef __NetBSD__
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, EV_ADD | EV_CLEAR, 
+			NOTE_EXIT | NOTE_FORK | NOTE_EXEC | NOTE_TRACK, 0, (intptr_t) TASK_VAL(t));
+#else
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, EV_ADD | EV_CLEAR, 
+			NOTE_EXIT | NOTE_FORK | NOTE_EXEC | NOTE_TRACK, 0, (void*) TASK_VAL(t));
+#endif
+	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -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;
+	}
+
+	return NULL;
+}
+
+/*
+ * sched_hook_signal() - Default SIGNAL hook
+ *
+ * @task = current task
+ * @arg = unused
+ * return: <0 errors and 0 ok
+ */
+void *
+sched_hook_signal(void *task, void *arg __unused)
+{
+	sched_task_t *t = task;
+	struct kevent chg[1];
+	struct timespec timeout = { 0, 0 };
+
+	if (!t || !TASK_ROOT(t))
+		return (void*) -1;
+
+#ifdef __NetBSD__
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_ADD, 0, 0, (intptr_t) TASK_VAL(t));
+#else
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, EV_ADD, 0, 0, (void*) TASK_VAL(t));
+#endif
+	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -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;
+	}
+
+	return NULL;
+}
+
+/*
+ * sched_hook_user() - Default USER hook
+ *
+ * @task = current task
+ * @arg = unused
+ * return: <0 errors and 0 ok
+ */
+#ifdef EVFILT_USER
+void *
+sched_hook_user(void *task, void *arg __unused)
+{
+	sched_task_t *t = task;
+	struct kevent chg[1];
+	struct timespec timeout = { 0, 0 };
+
+	if (!t || !TASK_ROOT(t))
+		return (void*) -1;
+
+#ifdef __NetBSD__
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, EV_ADD | EV_CLEAR, TASK_DATLEN(t), 
+			0, (intptr_t) TASK_VAL(t));
+#else
+	EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, EV_ADD | EV_CLEAR, TASK_DATLEN(t), 
+			0, (void*) TASK_VAL(t));
+#endif
+	if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -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;
+	}
+
+	return NULL;
+}
+#endif
+
+/*
  * sched_hook_fetch() - Default FETCH hook
  *
  * @root = root task
@@ -212,11 +429,11 @@ void *
 sched_hook_fetch(void *root, void *arg __unused)
 {
 	sched_root_task_t *r = root;
-	sched_task_t *task;
+	sched_task_t *task, *tmp;
 	struct timespec now, m, mtmp;
 	struct timespec *timeout;
 	struct kevent evt[1], res[KQ_EVENTS];
-	register int i;
+	register int i, flg;
 	int en;
 
 	if (!r)
@@ -318,9 +535,12 @@ sched_hook_fetch(void *root, void *arg __unused)
 		/* Put read/write task to ready queue */
 		switch (res[i].filter) {
 			case EVFILT_READ:
-				TAILQ_FOREACH(task, &r->root_read, task_node) {
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {
 					if (TASK_FD(task) != ((intptr_t) res[i].udata))
 						continue;
+					else
+						flg++;
 					/* remove read handle */
 #ifdef HAVE_LIBPTHREAD
 					pthread_mutex_lock(&r->root_mtx[taskREAD]);
@@ -359,13 +579,18 @@ sched_hook_fetch(void *root, void *arg __unused)
 						pthread_mutex_unlock(&r->root_mtx[taskREADY]);
 #endif
 					}
-					break;
 				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
 				break;
 			case EVFILT_WRITE:
-				TAILQ_FOREACH(task, &r->root_write, task_node) {
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {
 					if (TASK_FD(task) != ((intptr_t) res[i].udata))
 						continue;
+					else
+						flg++;
 					/* remove write handle */
 #ifdef HAVE_LIBPTHREAD
 					pthread_mutex_lock(&r->root_mtx[taskWRITE]);
@@ -404,9 +629,162 @@ sched_hook_fetch(void *root, void *arg __unused)
 						pthread_mutex_unlock(&r->root_mtx[taskREADY]);
 #endif
 					}
-					break;
 				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
 				break;
+			case EVFILT_TIMER:
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_alarm, task_node, tmp) {
+					if ((uintptr_t) TASK_DATA(task) != ((uintptr_t) res[i].udata))
+						continue;
+					else
+						flg++;
+					/* remove alarm handle */
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskALARM]);
+#endif
+					TAILQ_REMOVE(&r->root_alarm, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskALARM]);
+#endif
+					task->task_type = taskREADY;
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskREADY]);
+#endif
+					TAILQ_INSERT_TAIL(&r->root_ready, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskREADY]);
+#endif
+				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
+				break;
+			case EVFILT_VNODE:
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_node, task_node, tmp) {
+					if (TASK_FD(task) != ((intptr_t) res[i].udata))
+						continue;
+					else {
+						flg++;
+						TASK_DATA(task) = (void*) (uintptr_t) res[i].data;
+						TASK_DATLEN(task) = res[i].fflags;
+					}
+					/* remove node handle */
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskNODE]);
+#endif
+					TAILQ_REMOVE(&r->root_node, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskNODE]);
+#endif
+					task->task_type = taskREADY;
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskREADY]);
+#endif
+					TAILQ_INSERT_TAIL(&r->root_ready, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskREADY]);
+#endif
+				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
+				break;
+			case EVFILT_PROC:
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_proc, task_node, tmp) {
+					if (TASK_VAL(task) != ((uintptr_t) res[i].udata))
+						continue;
+					else {
+						flg++;
+						TASK_DATA(task) = (void*) (uintptr_t) res[i].data;
+						TASK_DATLEN(task) = res[i].fflags;
+					}
+					/* remove proc handle */
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskPROC]);
+#endif
+					TAILQ_REMOVE(&r->root_proc, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskPROC]);
+#endif
+					task->task_type = taskREADY;
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskREADY]);
+#endif
+					TAILQ_INSERT_TAIL(&r->root_ready, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskREADY]);
+#endif
+				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
+				break;
+			case EVFILT_SIGNAL:
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_signal, task_node, tmp) {
+					if (TASK_VAL(task) != ((uintptr_t) res[i].udata))
+						continue;
+					else
+						flg++;
+					/* remove signal handle */
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskSIGNAL]);
+#endif
+					TAILQ_REMOVE(&r->root_signal, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskSIGNAL]);
+#endif
+					task->task_type = taskREADY;
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskREADY]);
+#endif
+					TAILQ_INSERT_TAIL(&r->root_ready, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskREADY]);
+#endif
+				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
+				break;
+#ifdef EVFILT_USER
+			case EVFILT_USER:
+				flg = 0;
+				TAILQ_FOREACH_SAFE(task, &r->root_user, task_node, tmp) {
+					if (TASK_VAL(task) != ((uintptr_t) res[i].udata))
+						continue;
+					else {
+						flg++;
+						TASK_DATA(task) = (void*) res[i].data;
+						TASK_DATLEN(task) = res[i].fflags;
+					}
+					/* remove user handle */
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskUSER]);
+#endif
+					TAILQ_REMOVE(&r->root_user, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskUSER]);
+#endif
+					task->task_type = taskREADY;
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_lock(&r->root_mtx[taskREADY]);
+#endif
+					TAILQ_INSERT_TAIL(&r->root_ready, task, task_node);
+#ifdef HAVE_LIBPTHREAD
+					pthread_mutex_unlock(&r->root_mtx[taskREADY]);
+#endif
+				}
+				/* if match at least 2, don't remove resouce of event */
+				if (flg > 1)
+					evt->flags ^= evt->flags;
+				break;
+#endif
 		}
 		if (kevent(r->root_kq, evt, 1, NULL, 0, &now) == -1) {
 			if (r->root_hooks.hook_exec.exception) {
@@ -420,7 +798,7 @@ sched_hook_fetch(void *root, void *arg __unused)
 	/* timer update & put in ready queue */
 	clock_gettime(CLOCK_MONOTONIC, &now);
 
-	TAILQ_FOREACH(task, &r->root_timer, task_node)
+	TAILQ_FOREACH_SAFE(task, &r->root_timer, task_node, tmp)
 		if (sched_timespeccmp(&now, &TASK_TS(task), -) >= 0) {
 #ifdef HAVE_LIBPTHREAD
 			pthread_mutex_lock(&r->root_mtx[taskTIMER]);