--- libaitsched/inc/aitsched.h	2012/01/24 21:59:46	1.5
+++ libaitsched/inc/aitsched.h	2014/04/27 16:20:37	1.26
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: aitsched.h,v 1.5 2012/01/24 21:59:46 misho Exp $
+* $Id: aitsched.h,v 1.26 2014/04/27 16:20:37 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -12,7 +12,7 @@ terms:
 All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
 
-Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+Copyright 2004 - 2014
 	by Michael Pounov <misho@elwix.org>.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -49,17 +49,26 @@ SUCH DAMAGE.
 
 #include <sys/types.h>
 #include <sys/queue.h>
+#include <sys/select.h>
 #include <sys/uio.h>
 #include <stdint.h>
 #include <pthread.h>
+#include <assert.h>
+#ifdef EVFILT_LIO
+#include <aio.h>
+#endif
 
 
 /* criteria type */
-#define CRITERIA_CALL	0
-#define CRITERIA_ARG	1
-#define CRITERIA_FD	2
-#define CRITERIA_VAL	3
-#define CRITERIA_TV	4
+#define CRITERIA_ANY	0
+#define CRITERIA_CALL	1
+#define CRITERIA_ARG	2
+#define CRITERIA_FD	3
+#define CRITERIA_VAL	4
+#define CRITERIA_TS	5
+#define CRITERIA_DATA	6
+#define CRITERIA_DATLEN	7
+#define CRITERIA_ID	8
 
 
 /* early declaration for root & task */
@@ -70,10 +79,20 @@ typedef enum {
 	taskREAD = 0,
 	taskWRITE,
 	taskTIMER,
-	taskEVENT, 
-	taskEVENTLO, 
+	taskALARM,
+	taskNODE,
+	taskPROC,
+	taskSIGNAL,
+	taskAIO,
+	taskLIO,
+	taskUSER,
+	taskEVENT,
+	taskTASK,
+	taskSUSPEND, 
 	taskREADY,
 	taskUNUSE,
+	taskTHREAD, 
+	taskRTC,
 	taskMAX
 } sched_task_type_t;
 
@@ -85,22 +104,48 @@ struct sched_HooksTask {
 		sched_hook_func_t	read;
 		/* write(sched_task_t *task, NULL) -> int */
 		sched_hook_func_t	write;
-		/* event(sched_task_t *task, NULL) -> int */
-		sched_hook_func_t	event;
-		/* eventlo(sched_task_t *task, NULL) -> int */
-		sched_hook_func_t	eventlo;
 		/* timer(sched_task_t *task, struct timespec *ts) -> int */
 		sched_hook_func_t	timer;
+		/* alarm(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	alarm;
+		/* node(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	node;
+		/* proc(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	proc;
+		/* signal(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	signal;
+		/* aio(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	aio;
+		/* lio(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	lio;
+		/* user(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	user;
+		/* event(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	event;
+		/* task(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	task;
+		/* suspend(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	suspend;
+		/* thread(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	thread;
+		/* rtc(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	rtc;
 	}	hook_add;
 	struct {
+		/* exit(sched_task_t *task, void *exitValue) -> int */
+		sched_hook_func_t	exit;
 		/* cancel(sched_task_t *task, NULL) -> int */
 		sched_hook_func_t	cancel;
+		/* resume(sched_task_t *task, NULL) -> int */
+		sched_hook_func_t	resume;
 		/* run(sched_root_task_t *root, NULL) -> int */
 		sched_hook_func_t	run;
 		/* fetch(sched_root_task_t *root, NULL) -> sched_task_t* */
 		sched_hook_func_t	fetch;
 		/* exception(sched_root_task_t *root, NULL) -> int */
 		sched_hook_func_t	exception;
+		/* condition(sched_root_task_t *root, intptr_t *stopValue) -> int */
+		sched_hook_func_t	condition;
 	}	hook_exec;
 	struct {
 		/* init(sched_root_task_t *root, void *data) -> int */
@@ -115,22 +160,29 @@ typedef struct sched_HooksTask hooks_task_t;
 
 /* task callback, like pthread callback! */
 typedef void *(*sched_task_func_t)(sched_task_t * /* current task data*/);
+#define SCHED_TASK_DEFINE(x)	void *(x)(sched_task_t*)
 
 /* task lock helpers */
-#define TASK_LOCK(x)		((x)->task_lock++)
+#define TASK_LOCK(x)		((x)->task_lock = 42)
 #define TASK_UNLOCK(x)		((x)->task_lock ^= (x)->task_lock)
 #define TASK_ISLOCKED(x)	((x)->task_lock)
 
 /* task & queue */
 struct sched_Task {
-	volatile int			task_lock;
-	unsigned int			task_id;
+	uintptr_t			task_id;
+#define TASK_ID(x)	((struct sched_Task*) (x)->task_id)
 	sched_task_type_t		task_type;
 #define TASK_TYPE(x)	(x)->task_type
+	volatile int			task_lock;
 
 	sched_root_task_t		*task_root;
 #define TASK_ROOT(x)	(x)->task_root
 	sched_task_func_t		task_func;
+#define TASK_FUNC(x)	(x)->task_func
+	intptr_t			task_ret;
+#define TASK_RET(x)	(x)->task_ret
+	unsigned long			task_flag;
+#define TASK_FLAG(x)	(x)->task_flag
 
 	void				*task_arg;
 	union {
@@ -143,6 +195,9 @@ struct sched_Task {
 #define TASK_FD(x)	(x)->task_val.fd
 #define TASK_TS(x)	(x)->task_val.ts
 
+#define TASK_TS2TV(x, tvp)	(assert((tvp)), (tvp)->tv_sec = (x)->task_val.ts.tv_sec, \
+					(tvp)->tv_usec = (x)->task_val.ts.tv_nsec / 1000)
+
 	struct iovec			task_data;
 #define TASK_DATA(x)	(x)->task_data.iov_base
 #define TASK_DATLEN(x)	(x)->task_data.iov_len
@@ -160,32 +215,49 @@ typedef TAILQ_HEAD(, sched_Task) sched_queue_t;
 /* root task */
 struct sched_RootTask {
 	int		root_kq;
+	fd_set		root_fds[2];
 	struct timespec	root_wait;
 	struct timespec	root_poll;
+	unsigned long	root_miss;
+	intptr_t	root_cond;
+	void		*root_ret;
+
 	pthread_mutex_t	root_mtx[taskMAX];
 
 	sched_queue_t	root_read;
 	sched_queue_t	root_write;
 	sched_queue_t	root_timer;
+	sched_queue_t	root_alarm;
+	sched_queue_t	root_node;
+	sched_queue_t	root_proc;
+	sched_queue_t	root_signal;
+	sched_queue_t	root_aio;
+	sched_queue_t	root_lio;
+	sched_queue_t	root_user;
 	sched_queue_t	root_event;
+	sched_queue_t	root_task;
+	sched_queue_t	root_suspend;
 	sched_queue_t	root_ready;
 	sched_queue_t	root_unuse;
-	sched_queue_t	root_eventlo;
-	int		root_eventlo_miss;
+	sched_queue_t	root_thread;
+	sched_queue_t	root_rtc;
 
 	hooks_task_t	root_hooks;
 	struct iovec	root_data;
 #define ROOT_DATA(x)	(x)->root_data.iov_base
 #define ROOT_DATLEN(x)	(x)->root_data.iov_len
 };
+#define ROOT_QUEUE_EMPTY(x, _q)	TAILQ_EMPTY(&((x)->root_##_q))
+#define ROOT_RETURN(x)	(x)->root_ret
 
 
-inline int sched_GetErrno();
-inline const char *sched_GetError();
+int sched_GetErrno();
+const char *sched_GetError();
 
 
 /*
  * schedInit() - Init scheduler
+ *
  * @data = optional data if !=NULL
  * @datlen = data len if data is set
  * return: allocated root task if ok or NULL error
@@ -194,65 +266,118 @@ sched_root_task_t *schedInit(void ** __restrict data, 
 #define schedBegin()	schedInit((void**) &schedRegisterHooks, 0)
 /*
  * schedEnd() - End scheduler & free all resources
+ *
  * @root = root task
  * return: -1 error or 0 ok
  */
 int schedEnd(sched_root_task_t ** __restrict root);
 /*
  * schedRegisterHooks() - Register IO handles and bind tasks to it
+ *
  * @root = root task
  * return: -1 error or 0 ok
  */
 int schedRegisterHooks(sched_root_task_t * __restrict root);
 /*
+ * sched_useTask() - Get and init new task
+ *
+ * @root = root task
+ * return: NULL error or !=NULL prepared task
+ */
+sched_task_t *sched_useTask(sched_root_task_t * __restrict root);
+/*
+ * sched_unuseTask() - Unlock and put task to unuse queue
+ *
+ * @task = task
+ * return: always is NULL
+ */
+sched_task_t *sched_unuseTask(sched_task_t * __restrict task);
+/*
  * schedPolling() - Polling timeout period if no timer task is present
+ *
  * @root = root task
  * @ts = timeout polling period, if ==NULL INFINIT timeout
  * @tsold = old timeout polling if !=NULL
  * return: -1 error or 0 ok
  */
-inline int schedPolling(sched_root_task_t * __restrict root, 
+int schedPolling(sched_root_task_t * __restrict root, 
 		struct timespec * __restrict ts, struct timespec * __restrict tsold);
 /*
+ * schedTermCondition() - Activate hook for scheduler condition kill
+ *
+ * @root = root task
+ * @condValue = condition value, kill schedRun() if condValue == killState
+ * return: -1 error or 0 ok
+ */
+int schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue);
+/*
  * schedCall() - Call task execution function
+ *
  * @task = current task
  * return: !=NULL error or =NULL ok
  */
-inline void *schedCall(sched_task_t * __restrict task);
+void *schedCall(sched_task_t * __restrict task);
 /*
  * schedFetch() - Fetch ready task
+ *
  * @root = root task
  * return: =NULL error or !=NULL ready task
  */
-inline void *schedFetch(sched_root_task_t * __restrict root);
+void *schedFetch(sched_root_task_t * __restrict root);
 /*
  * schedRun() - Scheduler *run loop*
+ *
  * @root = root task
  * @killState = kill condition variable, if !=0 stop scheduler loop
  * return: -1 error or 0 ok
  */
-int schedRun(sched_root_task_t * __restrict root, volatile intptr_t * __restrict killState);
+int schedRun(sched_root_task_t *root, volatile intptr_t * __restrict killState);
 /*
  * schedCancel() - Cancel task from scheduler
+ *
  * @task = task
  * return: -1 error or 0 ok
  */
 int schedCancel(sched_task_t * __restrict task);
 /*
  * schedCancelby() - Cancel task from scheduler by criteria
+ *
  * @root = root task
  * @type = cancel from queue type, if =taskMAX cancel same task from all queues
- * @criteria = find task by criteria [CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|CRITERIA_TV]
+ * @criteria = find task by criteria 
+ * 	[ CRITERIA_ANY|CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|
+ * 		CRITERIA_ID|CRITERIA_TS|CRITERIA_DATA|CRITERIA_DATLEN ]
  * @param = search parameter
  * @hook = custom cleanup hook function, may be NULL
  * return: -1 error, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok
  */
 int schedCancelby(sched_root_task_t * __restrict root, sched_task_type_t type, 
-		u_char criteria, void *param, sched_hook_func_t hook);
+		unsigned char criteria, void *param, sched_hook_func_t hook);
+/*
+ * schedQuery() - Query task in scheduler
+ *
+ * @task = task
+ * return: -1 error, 0 found  and 1 not found
+ */
+int schedQuery(sched_task_t * __restrict task);
+/*
+ * schedQueryby() - Query task in scheduler by criteria
+ *
+ * @root = root task
+ * @type = query from queue type, if =taskMAX query same task from all queues
+ * @criteria = find task by criteria 
+ * 	[ CRITERIA_ANY|CRITERIA_CALL|CRITERIA_ARG|CRITERIA_FD|CRITERIA_VAL|
+ * 		CRITERIA_ID|CRITERIA_TS|CRITERIA_DATA|CRITERIA_DATLEN ]
+ * @param = search parameter
+ * return: -1 error, 0 found or 1 not found
+ */
+int schedQueryby(sched_root_task_t * __restrict root, sched_task_type_t type, 
+		unsigned char criteria, void *param);
 
 
 /*
  * schedRead() - Add READ I/O task to scheduler queue
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
@@ -263,8 +388,11 @@ int schedCancelby(sched_root_task_t * __restrict root,
  */
 sched_task_t *schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
 		int fd, void *opt_data, size_t opt_dlen);
+#define schedReadSelf(x)	schedRead(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_FD((x)), TASK_DATA((x)), TASK_DATLEN((x)))
 /*
  * schedWrite() - Add WRITE I/O task to scheduler queue
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
@@ -275,8 +403,196 @@ sched_task_t *schedRead(sched_root_task_t * __restrict
  */
 sched_task_t *schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
 		int fd, void *opt_data, size_t opt_dlen);
+#define schedWriteSelf(x)	schedWrite(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_FD((x)), TASK_DATA((x)), TASK_DATLEN((x)))
 /*
+ * schedAlarm() - Add ALARM task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @ts = timeout argument structure, minimum alarm timer resolution is 1msec!
+ * @opt_data = Alarm timer ID
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		struct timespec ts, void *opt_data, size_t opt_dlen);
+#define schedAlarmSelf(x)	schedAlarm(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_TS((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedRTC() - Add RTC task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @ts = timeout argument structure, minimum alarm timer resolution is 1msec!
+ * @opt_data = Optional RTC ID
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedRTC(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		struct timespec ts, void *opt_data, size_t opt_dlen);
+#define schedRTCSelf(x)		schedRTC(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_TS((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedNode() - Add NODE task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @fd = fd handle
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		int fd, void *opt_data, size_t opt_dlen);
+#define schedNodeSelf(x)	schedNode(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_FD((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedProc() - Add PROC task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @pid = PID
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		unsigned long pid, void *opt_data, size_t opt_dlen);
+#define schedProcSelf(x)	schedProc(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedSignal() - Add SIGNAL task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @sig = Signal
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		unsigned long sig, void *opt_data, size_t opt_dlen);
+#define schedSignalSelf(x)	schedSignal(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+
+#ifdef EVFILT_LIO
+/*
+ * schedAIO() - Add AIO task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @acb = AIO cb structure address
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen);
+/*
+ * schedAIORead() - Add AIO read task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @fd = file descriptor
+ * @buffer = Buffer
+ * @buflen = Buffer length
+ * @offset = Offset from start of file, if =-1 from current position
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, 
+		void *arg, int fd, void *buffer, size_t buflen, off_t offset);
+/*
+ * schedAIOWrite() - Add AIO write task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @fd = file descriptor
+ * @buffer = Buffer
+ * @buflen = Buffer length
+ * @offset = Offset from start of file, if =-1 from current position
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, 
+		void *arg, int fd, void *buffer, size_t buflen, off_t offset);
+
+/*
+ * schedLIO() - Add AIO bulk tasks to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @acbs = AIO cb structure addresses
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen);
+/*
+ * schedLIORead() - Add list of AIO read tasks to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @fd = file descriptor
+ * @bufs = Buffer's list
+ * @nbufs = Number of Buffers
+ * @offset = Offset from start of file, if =-1 from current position
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, 
+		void *arg, int fd, struct iovec *bufs, size_t nbufs, off_t offset);
+/*
+ * schedLIOWrite() - Add list of AIO write tasks to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @fd = file descriptor
+ * @bufs = Buffer's list
+ * @nbufs = Number of Buffers
+ * @offset = Offset from start of file, if =-1 from current position
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, 
+		void *arg, int fd, struct iovec *bufs, size_t nbufs, off_t offset);
+#endif	/* EVFILT_LIO */
+
+/*
+ * schedUser() - Add trigger USER task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @id = Trigger ID
+ * @opt_data = Optional data
+ * @opt_dlen = Optional user's trigger flags
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		unsigned long id, void *opt_data, size_t opt_dlen);
+#define schedUserSelf(x)	schedUser(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedTrigger() - Triggering USER task
+ *
+ * @task = task
+ * return: -1 error or 0 ok
+ */
+int schedTrigger(sched_task_t * __restrict task);
+
+/*
  * schedTimer() - Add TIMER task to scheduler queue
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
@@ -289,6 +605,7 @@ sched_task_t *schedTimer(sched_root_task_t * __restric
 		struct timespec ts, void *opt_data, size_t opt_dlen);
 /*
  * schedEvent() - Add EVENT task to scheduler queue
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
@@ -299,20 +616,52 @@ sched_task_t *schedTimer(sched_root_task_t * __restric
  */
 sched_task_t *schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
 		unsigned long val, void *opt_data, size_t opt_dlen);
+#define schedEventSelf(x)	schedEvent(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
 /*
- * schedEventLo() - Add EVENT_Lo task to scheduler queue
+ * schedTask() - Add regular task to scheduler queue
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
- * @val = additional func argument
+ * @prio = regular task priority, 0 is hi priority for regular tasks
  * @opt_data = Optional data
  * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task
  */
-sched_task_t *schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
-		unsigned long val, void *opt_data, size_t opt_dlen);
+sched_task_t *schedTask(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		unsigned long prio, void *opt_data, size_t opt_dlen);
+#define schedTaskSelf(x)	schedTask(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
 /*
+ * schedSuspend() - Add Suspended task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @id = Trigger ID
+ * @opt_data = Optional data
+ * @opt_dlen = Optional user's trigger flags
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedSuspend(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		unsigned long id, void *opt_data, size_t opt_dlen);
+#define schedSuspendSelf(x)	schedUser(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * schedResumeby() - Resume suspended task
+ *
+ * @root = root task
+ * @criteria = find task by criteria 
+ * 	[ CRITERIA_ANY|CRITERIA_ID|CRITERIA_VAL|CRITERIA_DATA ]
+ * @param = search parameter (sched_task_t *task| unsigned long id)
+ * return: -1 error or 0 resumed ok
+ */
+int schedResumeby(sched_root_task_t * __restrict root, unsigned char criteria, void *param);
+
+/*
  * schedCallOnce() - Call once from scheduler
+ *
  * @root = root task
  * @func = task execution function
  * @arg = 1st func argument
@@ -323,6 +672,40 @@ sched_task_t *schedEventLo(sched_root_task_t * __restr
  */
 sched_task_t *schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
 		unsigned long val, void *opt_data, size_t opt_dlen);
+#define schedCallAgain(x)	schedCallOnce(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		TASK_VAL((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+
+/*
+ * schedThread() - Add thread task to scheduler queue
+ *
+ * @root = root task
+ * @func = task execution function
+ * @arg = 1st func argument
+ * @ss = stack size
+ * @opt_data = Optional data
+ * @opt_dlen = Optional data length
+ * return: NULL error or !=NULL new queued task
+ */
+sched_task_t *schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
+		size_t ss, void *opt_data, size_t opt_dlen);
+#define schedThreadSelf(x)	schedThread(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
+		(size_t) TASK_FLAG((x)), TASK_DATA((x)), TASK_DATLEN((x)))
+/*
+ * sched_taskExit() - Exit routine for scheduler task, explicit required for thread tasks
+ *
+ * @task = current task
+ * @retcode = return code
+ * return: return code
+ */
+void *sched_taskExit(sched_task_t *task, intptr_t retcode);
+/*
+ * taskExit() - Exit helper for scheduler task
+ *
+ * @t = current executed task
+ * @x = exit value for task
+ * return: none
+ */
+#define taskExit(t, x)		return sched_taskExit((t), (intptr_t) (x))
 
 
 #endif