/*************************************************************************
* (C) 2011 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
* by Michael Pounov <misho@openbsd-bg.org>
*
* $Author: misho $
* $Id: aitsched.h,v 1.33 2024/03/20 12:52:49 misho Exp $
*
**************************************************************************
The ELWIX and AITNET software is distributed under the following
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 - 2024
by Michael Pounov <misho@elwix.org>. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this software
must display the following acknowledgement:
This product includes software developed by Michael Pounov <misho@elwix.org>
ELWIX - Embedded LightWeight unIX and its contributors.
4. Neither the name of AITNET nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
*/
#ifndef __AITSCHED_H
#define __AITSCHED_H
#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_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 */
typedef struct sched_Task sched_task_t;
typedef struct sched_RootTask sched_root_task_t;
typedef enum {
taskREAD = 0,
taskWRITE,
taskTIMER,
taskALARM,
taskNODE,
taskPROC,
taskSIGNAL,
taskAIO,
taskLIO,
taskUSER,
taskEVENT,
taskTASK,
taskSUSPEND,
taskREADY,
taskUNUSE,
taskTHREAD,
taskRTC,
taskMAX
} sched_task_type_t;
/* hooks */
typedef void *(*sched_hook_func_t)(void *, void *);
struct sched_HooksTask {
struct {
/* read(sched_task_t *task, NULL) -> int */
sched_hook_func_t read;
/* write(sched_task_t *task, NULL) -> int */
sched_hook_func_t write;
/* 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 */
sched_hook_func_t init;
/* fini(sched_root_task_t *root, NULL) -> int */
sched_hook_func_t fini;
/* error(sched_root_task_t *root, int errno) -> int */
sched_hook_func_t error;
} hook_root;
};
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 = 42)
#define TASK_UNLOCK(x) ((x)->task_lock ^= (x)->task_lock)
#define TASK_ISLOCKED(x) ((x)->task_lock)
/* task & queue */
struct sched_Task {
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 {
unsigned long v;
intptr_t fd;
struct timespec ts;
} task_val;
#define TASK_ARG(x) (x)->task_arg
#define TASK_VAL(x) (x)->task_val.v
#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
unsigned long task_harg;
#define TASK_HARG(x) (x)->task_harg
TAILQ_ENTRY(sched_Task) task_node;
};
typedef TAILQ_HEAD(, sched_Task) sched_queue_t;
#define TASK_DATA_SET(x, _dp, _dl) do { \
if ((x)) { \
(x)->task_data.iov_base = (_dp); \
(x)->task_data.iov_len = _dl; \
} \
while (0)
/* root task */
struct sched_RootTask {
int root_kq;
fd_set root_fds[3];
struct timespec root_wait;
struct timespec root_poll;
unsigned long root_miss;
intptr_t root_cond[1];
void *root_ret;
#ifdef HAVE_LIBPTHREAD
pthread_mutex_t root_sigmtx;
pthread_t root_sigthr;
sigset_t root_sigset;
sigset_t root_oldset;
#endif
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_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
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
*/
sched_root_task_t *schedInit(void ** __restrict data, size_t datlen);
#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
*/
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 * __restrict condValue);
/*
* schedCall() - Call task execution function
*
* @task = current task
* return: !=NULL error or =NULL ok
*/
void *schedCall(sched_task_t * __restrict task);
/*
* schedFetch() - Fetch ready task
*
* @root = root task
* return: =NULL error or !=NULL ready task
*/
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 *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_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,
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: NULL not found or !=NULL task
*/
sched_task_t *schedQueryby(sched_root_task_t * __restrict root, sched_task_type_t type,
unsigned char criteria, void *param);
/*
* schedSignalDispatch() - Activate or Deactivate signal dispatcher
*
* @root = root task
* @on = Activate or =0 deactivate
* return: -1 error, 1 already started, 2 another thread already started or 0 ok
*/
int schedSignalDispatch(sched_root_task_t * __restrict root, int on);
/*
* schedReadExt() - Add READ I/O task to scheduler queue with custom event mask
*
* @root = root task
* @func = task execution function
* @arg = 1st func argument
* @fd = fd handle
* @opt_data = Optional data
* @opt_dlen = Optional data length
* @mask = Event mask
* return: NULL error or !=NULL new queued task
*/
sched_task_t *schedReadExt(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
int fd, void *opt_data, size_t opt_dlen, unsigned long mask);
/*
* schedRead() - Add READ I/O 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 *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) schedReadExt(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
TASK_FD((x)), TASK_DATA((x)), TASK_DATLEN((x)), TASK_HARG((x)))
/*
* schedWriteExt() - Add WRITE I/O task to scheduler queue with custom event mask
*
* @root = root task
* @func = task execution function
* @arg = 1st func argument
* @fd = fd handle
* @opt_data = Optional data
* @opt_dlen = Optional data length
* @mask = Event mask
* return: NULL error or !=NULL new queued task
*/
sched_task_t *schedWriteExt(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
int fd, void *opt_data, size_t opt_dlen, unsigned long mask);
/*
* schedWrite() - Add WRITE I/O 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 *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) schedWriteExt(TASK_ROOT((x)), TASK_FUNC((x)), TASK_ARG((x)), \
TASK_FD((x)), TASK_DATA((x)), TASK_DATLEN((x)), TASK_HARG((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)))
/*
* schedNode2() - Add NODE task with all events 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 *schedNode2(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
int fd, void *opt_data, size_t opt_dlen);
#define schedNode2Self(x) schedNode2(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
* @ts = timeout argument structure
* @opt_data = Optional data
* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task
*/
sched_task_t *schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,
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
* @val = additional func argument
* @opt_data = Optional data
* @opt_dlen = Optional data length
* return: NULL error or !=NULL new queued task
*/
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)))
/*
* schedTask() - Add regular task to scheduler queue
*
* @root = root task
* @func = task execution function
* @arg = 1st 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 *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
* @val = additional func argument
* @opt_data = Optional data
* @opt_dlen = Optional data length
* return: return value from called func
*/
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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitsched.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / inc