libaitsched/src/aitsched.c - diff

Return to aitsched.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src

Diff for /libaitsched/src/aitsched.c between versions 1.1.1.1.2.4 and 1.18

version 1.1.1.1.2.4, 2011/08/13 17:28:17	version 1.18, 2013/05/30 09:13:52
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, 2005, 2006, 2007, 2008, 2009, 2010, 2011	Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
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 char sched_Error[STRSIZ];	Line 56 char sched_Error[STRSIZ];


// sched_GetErrno() Get error code of last operation	// sched_GetErrno() Get error code of last operation
inline int	int
sched_GetErrno()	sched_GetErrno()
{	{
return sched_Errno;	return sched_Errno;
}	}

// sched_GetError() Get error text of last operation	// sched_GetError() Get error text of last operation
inline const char *	const char *
sched_GetError()	sched_GetError()
{	{
return sched_Error;	return sched_Error;
}	}

// sched_SetErr() Set error to variables for internal use!!!	// sched_SetErr() Set error to variables for internal use!!!
inline void	void
sched_SetErr(int eno, char *estr, ...)	sched_SetErr(int eno, char *estr, ...)
{	{
va_list lst;	va_list lst;
Line 86 sched_SetErr(int eno, char *estr, ...)	Line 86 sched_SetErr(int eno, char *estr, ...)

/*	/*
* schedRegisterHooks() - Register IO handles and bind tasks to it	* schedRegisterHooks() - Register IO handles and bind tasks to it
	*
* @root = root task	* @root = root task
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
int	int
schedRegisterHooks(sched_root_task_t * __restrict root)	schedRegisterHooks(sched_root_task_t * __restrict root)
{	{
if (!root \|\| (root->root_data.iov_base && root->root_data.iov_len))	assert(root);
return -1;

if (root->root_hooks.hook_root.fini)	if (root->root_hooks.hook_root.fini)
root->root_hooks.hook_root.fini(root, NULL);	root->root_hooks.hook_root.fini(root, NULL);
Line 101 schedRegisterHooks(sched_root_task_t * __restrict root	Line 101 schedRegisterHooks(sched_root_task_t * __restrict root

root->root_hooks.hook_add.read = sched_hook_read;	root->root_hooks.hook_add.read = sched_hook_read;
root->root_hooks.hook_add.write = sched_hook_write;	root->root_hooks.hook_add.write = sched_hook_write;
	root->root_hooks.hook_add.alarm = sched_hook_alarm;
	root->root_hooks.hook_add.node = sched_hook_node;
	root->root_hooks.hook_add.proc = sched_hook_proc;
	root->root_hooks.hook_add.signal = sched_hook_signal;
	#ifdef EVFILT_USER
	root->root_hooks.hook_add.user = sched_hook_user;
	#endif
	#ifdef HAVE_LIBPTHREAD
	root->root_hooks.hook_add.thread = sched_hook_thread;
	#endif

root->root_hooks.hook_exec.cancel = sched_hook_cancel;	root->root_hooks.hook_exec.cancel = sched_hook_cancel;
root->root_hooks.hook_exec.fetch = sched_hook_fetch;	root->root_hooks.hook_exec.fetch = sched_hook_fetch;
	root->root_hooks.hook_exec.exception = sched_hook_exception;

root->root_hooks.hook_root.init = sched_hook_init;	root->root_hooks.hook_root.init = sched_hook_init;
root->root_hooks.hook_root.fini = sched_hook_fini;	root->root_hooks.hook_root.fini = sched_hook_fini;
Line 112 schedRegisterHooks(sched_root_task_t * __restrict root	Line 123 schedRegisterHooks(sched_root_task_t * __restrict root

/*	/*
* schedInit() - Init scheduler	* schedInit() - Init scheduler
	*
* @data = optional data if !=NULL	* @data = optional data if !=NULL
* @datlen = data len if data is set	* @datlen = data len if data is set
* return: allocated root task if ok or NULL error	* return: allocated root task if ok or NULL error
Line 121 schedInit(void ** __restrict data, size_t datlen)	Line 133 schedInit(void ** __restrict data, size_t datlen)
{	{
sched_root_task_t *root = NULL;	sched_root_task_t *root = NULL;
int (func)(sched_root_task_t );	int (func)(sched_root_task_t );
	#ifdef HAVE_LIBPTHREAD
	register int i;
	#endif

root = malloc(sizeof(sched_root_task_t));	root = malloc(sizeof(sched_root_task_t));
if (!root) {	if (!root) {
LOGERR;	LOGERR;
} else {	} else {
memset(root, 0, sizeof(sched_root_task_t));	memset(root, 0, sizeof(sched_root_task_t));

	/* set default maximum regular task hit misses */
	root->root_miss = MAX_TASK_MISS;

	/* INFINIT polling period by default */
	sched_timespecinf(&root->root_poll);

	#ifdef HAVE_LIBPTHREAD
	for (i = 0; i < taskMAX; i++)
	if ((errno = pthread_mutex_init(&root->root_mtx[i], NULL))) {
	LOGERR;
	while (i)
	pthread_mutex_destroy(&root->root_mtx[--i]);
	free(root);
	return NULL;
	}

	for (i = 0; i < taskMAX; i++)
	pthread_mutex_lock(&root->root_mtx[i]);
	#endif

TAILQ_INIT(&root->root_read);	TAILQ_INIT(&root->root_read);
TAILQ_INIT(&root->root_write);	TAILQ_INIT(&root->root_write);
TAILQ_INIT(&root->root_timer);	TAILQ_INIT(&root->root_timer);
	TAILQ_INIT(&root->root_alarm);
	TAILQ_INIT(&root->root_node);
	TAILQ_INIT(&root->root_proc);
	TAILQ_INIT(&root->root_signal);
	TAILQ_INIT(&root->root_aio);
	TAILQ_INIT(&root->root_lio);
	TAILQ_INIT(&root->root_user);
TAILQ_INIT(&root->root_event);	TAILQ_INIT(&root->root_event);
TAILQ_INIT(&root->root_eventlo);	TAILQ_INIT(&root->root_task);
	TAILQ_INIT(&root->root_suspend);
TAILQ_INIT(&root->root_ready);	TAILQ_INIT(&root->root_ready);
TAILQ_INIT(&root->root_unuse);	TAILQ_INIT(&root->root_unuse);
	TAILQ_INIT(&root->root_thread);

	#ifdef HAVE_LIBPTHREAD
	for (i = 0; i < taskMAX; i++)
	pthread_mutex_unlock(&root->root_mtx[i]);
	#endif

if (data && *data) {	if (data && *data) {
if (datlen) {	if (datlen) {
root->root_data.iov_base = *data;	root->root_data.iov_base = *data;
root->root_data.iov_len = datlen;	root->root_data.iov_len = datlen;
} else {	} else { /* if datlen == 0, switch to callbacks init mode */
	/* little hack :) for correct initialization of scheduler */
func = (int()(sched_root_task_t)) data;	func = (int()(sched_root_task_t)) data;
func(root);	func(root);
}	}
Line 154 schedInit(void ** __restrict data, size_t datlen)	Line 205 schedInit(void ** __restrict data, size_t datlen)

/*	/*
* schedEnd() - End scheduler & free all resources	* schedEnd() - End scheduler & free all resources
	*
* @root = root task	* @root = root task
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
int	int
schedEnd(sched_root_task_t * __restrict root)	schedEnd(sched_root_task_t ** __restrict root)
{	{
sched_task_t *task;	sched_task_t task, tmp;
	#ifdef HAVE_LIBPTHREAD
	register int i;
	#endif

if (!root)	if (!root \|\| !*root)
return -1;	return -1;

TAILQ_FOREACH(task, &root->root_read, task_node) {	TAILQ_FOREACH_SAFE(task, &(*root)->root_read, task_node, tmp)
schedCancel(task);	schedCancel(task);
}	TAILQ_FOREACH_SAFE(task, &(*root)->root_write, task_node, tmp)
TAILQ_FOREACH(task, &root->root_write, task_node) {
schedCancel(task);	schedCancel(task);
}	TAILQ_FOREACH_SAFE(task, &(*root)->root_timer, task_node, tmp)
TAILQ_FOREACH(task, &root->root_timer, task_node) {
schedCancel(task);	schedCancel(task);
}	TAILQ_FOREACH_SAFE(task, &(*root)->root_alarm, task_node, tmp)
TAILQ_FOREACH(task, &root->root_event, task_node) {
schedCancel(task);	schedCancel(task);
}	TAILQ_FOREACH_SAFE(task, &(*root)->root_node, task_node, tmp)
TAILQ_FOREACH(task, &root->root_ready, task_node) {
schedCancel(task);	schedCancel(task);
}	TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_aio, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_lio, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_user, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_event, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_suspend, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_thread, task_node, tmp)
	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_task, task_node, tmp)
	schedCancel(task);

while ((task = TAILQ_FIRST(&root->root_unuse))) {	#ifdef HAVE_LIBPTHREAD
TAILQ_REMOVE(&root->root_unuse, task, task_node);	pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]);
	#endif
	TAILQ_FOREACH_SAFE(task, &(*root)->root_unuse, task_node, tmp) {
	TAILQ_REMOVE(&(*root)->root_unuse, task, task_node);
free(task);	free(task);
}	}
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&(*root)->root_mtx[taskUNUSE]);
	#endif

if (root->root_hooks.hook_root.fini)	if ((*root)->root_hooks.hook_root.fini)
root->root_hooks.hook_root.fini(root, NULL);	(root)->root_hooks.hook_root.fini(root, NULL);

free(root);	#ifdef HAVE_LIBPTHREAD
	for (i = 0; i < taskMAX; i++)
	pthread_mutex_destroy(&(*root)->root_mtx[i]);
	#endif

	free(*root);
	*root = NULL;
return 0;	return 0;
}	}

/*	/*
* schedCall() - Call task execution function	* schedCall() - Call task execution function
	*
* @task = current task	* @task = current task
* return: !=NULL error or =NULL ok	* return: !=NULL error or =NULL ok
*/	*/
inline void *	void *
schedCall(sched_task_t * __restrict task)	schedCall(sched_task_t * __restrict task)
{	{
	void ptr = (void) -1;

if (!task)	if (!task)
return (void*) -1;	return ptr;

task->task_id++;	if (!TASK_ISLOCKED(task))
return task->task_func(task);	TASK_LOCK(task);

	ptr = task->task_func(task);

	TASK_UNLOCK(task);
	return ptr;
}	}

/*	/*
* schedFetch() - Fetch ready task	* schedFetch() - Fetch ready task
	*
* @root = root task	* @root = root task
* return: =NULL error or !=NULL ready task	* return: =NULL error or !=NULL ready task
*/	*/
inline void *	void *
schedFetch(sched_root_task_t * __restrict root)	schedFetch(sched_root_task_t * __restrict root)
{	{
void *ptr;	void *ptr;
Line 230 schedFetch(sched_root_task_t * __restrict root)	Line 321 schedFetch(sched_root_task_t * __restrict root)
}	}

/*	/*
	* schedTrigger() - Triggering USER task
	*
	* @task = task
	* return: -1 error or 0 ok
	*/
	int
	schedTrigger(sched_task_t * __restrict task)
	{
	#ifndef EVFILT_USER
	sched_SetErr(ENOTSUP, "Not supported kevent() filter");
	return -1;
	#else
	struct kevent chg[1];
	struct timespec timeout = { 0, 0 };

	if (!task \|\| !TASK_ROOT(task))
	return -1;

	#ifdef __NetBSD__
	EV_SET(chg, TASK_VAL(task), EVFILT_USER, 0, NOTE_TRIGGER, 0, (intptr_t) TASK_VAL(task));
	#else
	EV_SET(chg, TASK_VAL(task), EVFILT_USER, 0, NOTE_TRIGGER, 0, (void*) TASK_VAL(task));
	#endif
	if (kevent(TASK_ROOT(task)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
	LOGERR;
	return -1;
	}

	return 0;
	#endif
	}

	/*
* schedCancel() - Cancel task from scheduler	* schedCancel() - Cancel task from scheduler
	*
* @task = task	* @task = task
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
Line 239 schedCancel(sched_task_t * __restrict task)	Line 364 schedCancel(sched_task_t * __restrict task)
{	{
sched_queue_t *queue;	sched_queue_t *queue;

if (!task \|\| !task->task_root)	if (!task \|\| !TASK_ROOT(task))
return -1;	return -1;

if (task->task_root->root_hooks.hook_exec.cancel)	if (TASK_ROOT(task)->root_hooks.hook_exec.cancel)
if (task->task_root->root_hooks.hook_exec.cancel(task, NULL))	if (TASK_ROOT(task)->root_hooks.hook_exec.cancel(task, NULL))
return -1;	return -1;

switch (task->task_type) {	switch (TASK_TYPE(task)) {
case taskREAD:	case taskREAD:
queue = &task->task_root->root_read;	queue = &TASK_ROOT(task)->root_read;
break;	break;
case taskWRITE:	case taskWRITE:
queue = &task->task_root->root_write;	queue = &TASK_ROOT(task)->root_write;
break;	break;
case taskTIMER:	case taskTIMER:
queue = &task->task_root->root_timer;	queue = &TASK_ROOT(task)->root_timer;
break;	break;
	case taskALARM:
	queue = &TASK_ROOT(task)->root_alarm;
	break;
	case taskNODE:
	queue = &TASK_ROOT(task)->root_node;
	break;
	case taskPROC:
	queue = &TASK_ROOT(task)->root_proc;
	break;
	case taskSIGNAL:
	queue = &TASK_ROOT(task)->root_signal;
	break;
	case taskAIO:
	queue = &TASK_ROOT(task)->root_aio;
	break;
	case taskLIO:
	queue = &TASK_ROOT(task)->root_lio;
	break;
	case taskUSER:
	queue = &TASK_ROOT(task)->root_user;
	break;
case taskEVENT:	case taskEVENT:
queue = &task->task_root->root_event;	queue = &TASK_ROOT(task)->root_event;
break;	break;
	case taskTASK:
	queue = &TASK_ROOT(task)->root_task;
	break;
	case taskSUSPEND:
	queue = &TASK_ROOT(task)->root_suspend;
	break;
case taskREADY:	case taskREADY:
queue = &task->task_root->root_ready;	queue = &TASK_ROOT(task)->root_ready;
break;	break;
	case taskTHREAD:
	queue = &TASK_ROOT(task)->root_thread;
	break;
default:	default:
queue = NULL;	queue = NULL;
}	}
if (queue)	if (queue) {
TAILQ_REMOVE(queue, task, task_node);	#ifdef HAVE_LIBPTHREAD
if (task->task_type != taskUNUSE) {	pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[TASK_TYPE(task)]);
task->task_type = taskUNUSE;	#endif
TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node);	TAILQ_REMOVE(queue, TASK_ID(task), task_node);
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[TASK_TYPE(task)]);
	#endif
}	}
	if (TASK_TYPE(task) != taskUNUSE)
	sched_unuseTask(task);

return 0;	return 0;
}	}

/*	/*
* schedCancelby() - Cancel task from scheduler by criteria	* schedCancelby() - Cancel task from scheduler by criteria
	*
* @root = root task	* @root = root task
* @queue = cancel from queue, if =NULL cancel same task from all queues	* @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]
* @param = search parameter	* @param = search parameter
* @hook = custom cleanup hook function, may be NULL	* @hook = custom cleanup hook function, may be NULL
* return: -1 error or 0 ok	* return: -1 error, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok
*/	*/
int	int
schedCancelby(sched_root_task_t * __restrict root, sched_queue_t * __restrict queue,	schedCancelby(sched_root_task_t * __restrict root, sched_task_type_t type,
u_char criteria, void *param, sched_hook_func_t hook)	u_char criteria, void *param, sched_hook_func_t hook)
{	{
sched_task_t *task;	sched_task_t task, tmp;
int flg = 0;	sched_queue_t *queue;
	register int flg = 0;

if (!root)	if (!root)
return -1;	return -1;
if (!queue) {	/* if type == taskMAX check in all queues */
if (schedCancelby(root, &root->root_read, criteria, param, hook))	if (type == taskMAX) {
	if (schedCancelby(root, taskREAD, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, &root->root_write, criteria, param, hook))	if (schedCancelby(root, taskWRITE, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, &root->root_timer, criteria, param, hook))	if (schedCancelby(root, taskTIMER, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, &root->root_event, criteria, param, hook))	if (schedCancelby(root, taskALARM, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, &root->root_ready, criteria, param, hook))	if (schedCancelby(root, taskNODE, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, &root->root_read, criteria, param, hook))	if (schedCancelby(root, taskPROC, criteria, param, hook))
return -2;	return -2;
	if (schedCancelby(root, taskSIGNAL, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskAIO, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskLIO, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskUSER, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskEVENT, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskTASK, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskSUSPEND, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskREADY, criteria, param, hook))
	return -2;
	if (schedCancelby(root, taskTHREAD, criteria, param, hook))
	return -2;
return 0;	return 0;
}	}
	/* choosen queue */
	switch (type) {
	case taskREAD:
	queue = &root->root_read;
	break;
	case taskWRITE:
	queue = &root->root_write;
	break;
	case taskTIMER:
	queue = &root->root_timer;
	break;
	case taskALARM:
	queue = &root->root_alarm;
	break;
	case taskNODE:
	queue = &root->root_node;
	break;
	case taskPROC:
	queue = &root->root_proc;
	break;
	case taskSIGNAL:
	queue = &root->root_signal;
	break;
	case taskAIO:
	queue = &root->root_aio;
	break;
	case taskLIO:
	queue = &root->root_lio;
	break;
	case taskUSER:
	queue = &root->root_user;
	break;
	case taskEVENT:
	queue = &root->root_event;
	break;
	case taskTASK:
	queue = &root->root_task;
	break;
	case taskSUSPEND:
	queue = &root->root_suspend;
	break;
	case taskREADY:
	queue = &root->root_ready;
	break;
	case taskTHREAD:
	queue = &root->root_thread;
	break;
	default:
	return 0;
	}

TAILQ_FOREACH(task, queue, task_node)	#ifdef HAVE_LIBPTHREAD
if (criteria == CRITERIA_CALL) {	pthread_mutex_lock(&root->root_mtx[type]);
if (task->task_func == (sched_task_func_t) param) {	#endif
flg++;	TAILQ_FOREACH_SAFE(task, queue, task_node, tmp) {
	flg ^= flg;
	switch (criteria) {
	case CRITERIA_ANY:
	flg = 1;
break;	break;
}	case CRITERIA_CALL:
} else if (criteria == CRITERIA_ARG) {	if (TASK_FUNC(task) == (sched_task_func_t) param)
if (task->task_arg == param) {	flg = 1;
flg++;
break;	break;
}	case CRITERIA_ARG:
} else if (criteria == CRITERIA_FD) {	if (TASK_ARG(task) == param)
if (TASK_FD(task) == (u_long) param) {	flg = 1;
flg++;
break;	break;
}	case CRITERIA_FD:
} else if (criteria == CRITERIA_VAL) {	if (TASK_FD(task) == (intptr_t) param)
if (TASK_VAL(task) == (u_long) param) {	flg = 1;
flg++;
break;	break;
}	case CRITERIA_ID:
} else if (criteria == CRITERIA_TV) {	case CRITERIA_VAL:
if (&TASK_TV(task) == (struct timeval*) param) {	if (TASK_VAL(task) == (u_long) param)
flg++;	flg = 1;
break;	break;
}	case CRITERIA_TS:
} else {	if (!sched_timespeccmp(&TASK_TS(task), (struct timespec*) param, -))
sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria);	flg = 1;
return -1;	break;
	case CRITERIA_DATA:
	if (TASK_DATA(task) == param)
	flg = 1;
	break;
	default:
	sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria);
	flg = -1;
}	}
if (!flg \|\| !task) /* task not found */	if (flg < 0) /* error */
return 0;	break;
	/* cancel choosen task */
	if (flg > 0) {
	if (TASK_ROOT(task)->root_hooks.hook_exec.cancel)
	if (TASK_ROOT(task)->root_hooks.hook_exec.cancel(task, NULL)) {
	flg = -1;
	break;
	}
	/* custom hook */
	if (hook)
	if (hook(task, NULL)) {
	flg = -3;
	break;
	}

if (task->task_root->root_hooks.hook_exec.cancel)	TAILQ_REMOVE(queue, task, task_node);
if (task->task_root->root_hooks.hook_exec.cancel(task, NULL))	if (TASK_TYPE(task) != taskUNUSE)
return -1;	sched_unuseTask(task);
if (hook)
if (hook(task, NULL))
return -3;

TAILQ_REMOVE(queue, task, task_node);	flg ^= flg; /* ok */
	}
if (task->task_type != taskUNUSE) {
task->task_type = taskUNUSE;
TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node);
}	}
return 0;	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&root->root_mtx[type]);
	#endif
	return flg;
}	}

/*	/*
* schedRun() - Scheduler run loop	* schedRun() - Scheduler run loop
	*
* @root = root task	* @root = root task
	* @killState = kill condition variable, if !=0 stop scheduler loop
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
int	int
schedRun(sched_root_task_t * __restrict root)	schedRun(sched_root_task_t root, volatile intptr_t __restrict killState)
{	{
sched_task_t *task;	sched_task_t *task;

Line 374 schedRun(sched_root_task_t * __restrict root)	Line 626 schedRun(sched_root_task_t * __restrict root)
if (root->root_hooks.hook_exec.run)	if (root->root_hooks.hook_exec.run)
if (root->root_hooks.hook_exec.run(root, NULL))	if (root->root_hooks.hook_exec.run(root, NULL))
return -1;	return -1;
if (root->root_hooks.hook_exec.fetch)
while ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
schedCall(task);

	if (killState) {
	if (root->root_hooks.hook_exec.condition)
	/* condition scheduler loop */
	while (root && root->root_hooks.hook_exec.fetch &&
	root->root_hooks.hook_exec.condition &&
	root->root_hooks.hook_exec.condition(root, (void*) killState)) {
	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
	root->root_ret = schedCall(task);
	}
	else
	/* trigger scheduler loop */
	while (!*killState && root && root->root_hooks.hook_exec.fetch) {
	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
	root->root_ret = schedCall(task);
	}
	} else
	/* infinite scheduler loop */
	while (root && root->root_hooks.hook_exec.fetch)
	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
	root->root_ret = schedCall(task);

return 0;	return 0;
	}

	/*
	* 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)
	{
	if (!root)
	return -1;

	if (tsold)
	*tsold = root->root_poll;

	if (!ts)
	sched_timespecinf(&root->root_poll);
	else
	root->root_poll = *ts;

	return 0;
	}

	/*
	* 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)
	{
	if (!root)
	return -1;

	root->root_cond = condValue;
	root->root_hooks.hook_exec.condition = sched_hook_condition;
	return 0;
	}

	/*
	* schedResumeby() - Resume suspended task
	*
	* @root = root task
	* @criteria = find task by criteria
	* [CRITERIA_ANY\|CRITERIA_ID\|CRITERIA_DATA]
	* @param = search parameter (sched_task_t *task\| u_long id)
	* return: -1 error or 0 resumed ok
	*/
	int
	schedResumeby(sched_root_task_t * __restrict root, u_char criteria, void *param)
	{
	sched_task_t task, tmp;
	register int flg = 0;

	if (!root)
	return -1;

	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskSUSPEND]);
	#endif
	TAILQ_FOREACH_SAFE(task, &root->root_suspend, task_node, tmp) {
	flg ^= flg;
	switch (criteria) {
	case CRITERIA_ANY:
	flg = 1;
	break;
	case CRITERIA_ID:
	if (TASK_VAL(task) == (u_long) param)
	flg = 1;
	break;
	case CRITERIA_DATA:
	if (TASK_ID(task) == (sched_task_t*) param)
	flg = 1;
	break;
	default:
	sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria);
	flg = -1;
	}
	if (flg < 0)
	break;
	/* resume choosen task */
	if (flg > 0) {
	if (root->root_hooks.hook_exec.resume)
	if (root->root_hooks.hook_exec.resume(task, NULL)) {
	flg = -1;
	break;
	}

	TAILQ_REMOVE(&root->root_suspend, task, task_node);

	task->task_type = taskREADY;
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_lock(&root->root_mtx[taskREADY]);
	#endif
	TAILQ_INSERT_TAIL(&root->root_ready, task, task_node);
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&root->root_mtx[taskREADY]);
	#endif

	flg ^= flg; /* ok */
	}
	}
	#ifdef HAVE_LIBPTHREAD
	pthread_mutex_unlock(&root->root_mtx[taskSUSPEND]);
	#endif

	return flg;
}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1.2.4
changed lines
	Added in v.1.18