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.10.6.1 and 1.24.4.1

version 1.10.6.1, 2012/07/24 13:47:01	version 1.24.4.1, 2014/02/01 14:06:08
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, 2012	Copyright 2004 - 2014
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 102 schedRegisterHooks(sched_root_task_t * __restrict root	Line 102 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.alarm = sched_hook_alarm;
	#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
	root->root_hooks.hook_add.rtc = sched_hook_rtc;
	#endif
root->root_hooks.hook_add.node = sched_hook_node;	root->root_hooks.hook_add.node = sched_hook_node;
root->root_hooks.hook_add.proc = sched_hook_proc;	root->root_hooks.hook_add.proc = sched_hook_proc;
root->root_hooks.hook_add.signal = sched_hook_signal;	root->root_hooks.hook_add.signal = sched_hook_signal;
#ifdef EVFILT_USER	#ifdef EVFILT_USER
root->root_hooks.hook_add.user = sched_hook_user;	root->root_hooks.hook_add.user = sched_hook_user;
#endif	#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;
Line 140 schedInit(void ** __restrict data, size_t datlen)	Line 146 schedInit(void ** __restrict data, size_t datlen)
} 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 */	/* INFINIT polling period by default */
sched_timespecinf(&root->root_poll);	sched_timespecinf(&root->root_poll);

#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
for (i = 0; i < taskMAX; i++)	for (i = 0; i < taskMAX; i++)
if (pthread_mutex_init(&root->root_mtx[i], NULL)) {	if ((errno = pthread_mutex_init(&root->root_mtx[i], NULL))) {
LOGERR;	LOGERR;
while (i)	while (i)
pthread_mutex_destroy(&root->root_mtx[--i]);	pthread_mutex_destroy(&root->root_mtx[--i]);
Line 161 schedInit(void ** __restrict data, size_t datlen)	Line 170 schedInit(void ** __restrict data, size_t datlen)
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_alarm);
	TAILQ_INIT(&root->root_rtc);
TAILQ_INIT(&root->root_node);	TAILQ_INIT(&root->root_node);
TAILQ_INIT(&root->root_proc);	TAILQ_INIT(&root->root_proc);
TAILQ_INIT(&root->root_user);
TAILQ_INIT(&root->root_signal);	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_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	#ifdef HAVE_LIBPTHREAD
for (i = 0; i < taskMAX; i++)	for (i = 0; i < taskMAX; i++)
Line 219 schedEnd(sched_root_task_t ** __restrict root)	Line 232 schedEnd(sched_root_task_t ** __restrict root)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_alarm, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_alarm, task_node, tmp)
schedCancel(task);	schedCancel(task);
	TAILQ_FOREACH_SAFE(task, &(*root)->root_rtc, task_node, tmp)
	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_node, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_node, task_node, tmp)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_proc, task_node, tmp)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_user, task_node, tmp)
schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_signal, task_node, tmp)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_event, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_aio, task_node, tmp)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_eventlo, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_lio, task_node, tmp)
schedCancel(task);	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)	TAILQ_FOREACH_SAFE(task, &(*root)->root_suspend, task_node, tmp)
schedCancel(task);	schedCancel(task);
TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp)	TAILQ_FOREACH_SAFE(task, &(*root)->root_ready, task_node, tmp)
schedCancel(task);	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);

#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]);	pthread_mutex_lock(&(*root)->root_mtx[taskUNUSE]);
Line 266 schedEnd(sched_root_task_t ** __restrict root)	Line 287 schedEnd(sched_root_task_t ** __restrict root)
* @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;	void ptr = (void) -1;
Line 289 schedCall(sched_task_t * __restrict task)	Line 310 schedCall(sched_task_t * __restrict 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 314 schedFetch(sched_root_task_t * __restrict root)	Line 335 schedFetch(sched_root_task_t * __restrict root)
int	int
schedTrigger(sched_task_t * __restrict task)	schedTrigger(sched_task_t * __restrict task)
{	{
	#ifdef KQ_DISABLE
	sched_SetErr(ENOTSUP, "disabled kqueue support");
	return -1;
	#else
#ifndef EVFILT_USER	#ifndef EVFILT_USER
sched_SetErr(ENOTSUP, "Not supported kevent() filter");	sched_SetErr(ENOTSUP, "Not supported kevent() filter");
return -1;	return -1;
Line 336 schedTrigger(sched_task_t * __restrict task)	Line 361 schedTrigger(sched_task_t * __restrict task)

return 0;	return 0;
#endif	#endif
	#endif /* KQ_DISABLE */
}	}

/*	/*
	* schedQuery() - Query task in scheduler
	*
	* @task = task
	* return: -1 error, 0 found and 1 not found
	*/
	int
	schedQuery(sched_task_t * __restrict task)
	{
	sched_queue_t *queue;
	sched_task_t *t;

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

	switch (TASK_TYPE(task)) {
	case taskREAD:
	queue = &TASK_ROOT(task)->root_read;
	break;
	case taskWRITE:
	queue = &TASK_ROOT(task)->root_write;
	break;
	case taskTIMER:
	queue = &TASK_ROOT(task)->root_timer;
	break;
	case taskALARM:
	queue = &TASK_ROOT(task)->root_alarm;
	break;
	case taskRTC:
	queue = &TASK_ROOT(task)->root_rtc;
	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:
	queue = &TASK_ROOT(task)->root_event;
	break;
	case taskTASK:
	queue = &TASK_ROOT(task)->root_task;
	break;
	case taskSUSPEND:
	queue = &TASK_ROOT(task)->root_suspend;
	break;
	case taskREADY:
	queue = &TASK_ROOT(task)->root_ready;
	break;
	case taskTHREAD:
	queue = &TASK_ROOT(task)->root_thread;
	break;
	default:
	return 1; /* not in queue */
	}
	if (queue)
	TAILQ_FOREACH(t, queue, task_node)
	if (TASK_ID(t) == TASK_ID(task))
	return 0; /* found */

	return 1; /* not in queue */
	}

	/*
	* 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,
	u_char criteria, void *param)
	{
	sched_task_t *task;
	sched_queue_t *queue;
	register int flg = 0;

	if (!root)
	return -1;
	/* if type == taskMAX check in all queues */
	if (type == taskMAX) {
	if ((flg = schedQueryby(root, taskREAD, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskWRITE, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskTIMER, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskALARM, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskRTC, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskNODE, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskPROC, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskSIGNAL, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskAIO, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskLIO, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskUSER, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskEVENT, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskTASK, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskSUSPEND, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskREADY, criteria, param)) < 1)
	return flg;
	if ((flg = schedQueryby(root, taskTHREAD, criteria, param)) < 1)
	return flg;
	return 1; /* not found */
	}
	/* 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 taskRTC:
	queue = &root->root_rtc;
	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 1; /* not found */
	}

	TAILQ_FOREACH(task, queue, task_node) {
	switch (criteria) {
	case CRITERIA_ANY:
	return 0; /* found */
	case CRITERIA_CALL:
	if (TASK_FUNC(task) == (sched_task_func_t) param)
	return 0; /* found */
	break;
	case CRITERIA_ARG:
	if (TASK_ARG(task) == param)
	return 0; /* found */
	break;
	case CRITERIA_FD:
	if (TASK_FD(task) == (intptr_t) param)
	return 0; /* found */
	break;
	case CRITERIA_ID:
	case CRITERIA_VAL:
	if (TASK_VAL(task) == (u_long) param)
	return 0; /* found */
	break;
	case CRITERIA_TS:
	if (!sched_timespeccmp(&TASK_TS(task),
	(struct timespec*) param, -))
	return 0; /* found */
	break;
	case CRITERIA_DATA:
	if (TASK_DATA(task) == param)
	return 0; /* found */
	break;
	case CRITERIA_DATLEN:
	if (TASK_DATLEN(task) == (size_t) param)
	return 0; /* found */
	break;
	default:
	sched_SetErr(EINVAL, "Invalid parameter criteria %d",
	criteria);
	return 1; /* not found */
	}
	}

	return 1; /* not found */
	}

	/*
* schedCancel() - Cancel task from scheduler	* schedCancel() - Cancel task from scheduler
*	*
* @task = task	* @task = task
Line 369 schedCancel(sched_task_t * __restrict task)	Line 625 schedCancel(sched_task_t * __restrict task)
case taskALARM:	case taskALARM:
queue = &TASK_ROOT(task)->root_alarm;	queue = &TASK_ROOT(task)->root_alarm;
break;	break;
	case taskRTC:
	queue = &TASK_ROOT(task)->root_rtc;
	break;
case taskNODE:	case taskNODE:
queue = &TASK_ROOT(task)->root_node;	queue = &TASK_ROOT(task)->root_node;
break;	break;
case taskPROC:	case taskPROC:
queue = &TASK_ROOT(task)->root_proc;	queue = &TASK_ROOT(task)->root_proc;
break;	break;
case taskUSER:
queue = &TASK_ROOT(task)->root_user;
break;
case taskSIGNAL:	case taskSIGNAL:
queue = &TASK_ROOT(task)->root_signal;	queue = &TASK_ROOT(task)->root_signal;
break;	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_ROOT(task)->root_event;	queue = &TASK_ROOT(task)->root_event;
break;	break;
case taskEVENTLO:	case taskTASK:
queue = &TASK_ROOT(task)->root_eventlo;	queue = &TASK_ROOT(task)->root_task;
break;	break;
case taskSUSPEND:	case taskSUSPEND:
queue = &TASK_ROOT(task)->root_suspend;	queue = &TASK_ROOT(task)->root_suspend;
Line 393 schedCancel(sched_task_t * __restrict task)	Line 658 schedCancel(sched_task_t * __restrict task)
case taskREADY:	case taskREADY:
queue = &TASK_ROOT(task)->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;
}	}
Line 406 schedCancel(sched_task_t * __restrict task)	Line 674 schedCancel(sched_task_t * __restrict task)
#endif	#endif
}	}
if (TASK_TYPE(task) != taskUNUSE)	if (TASK_TYPE(task) != taskUNUSE)
_sched_unuseTask(task);	sched_unuseTask(task);

return 0;	return 0;
}	}
Line 417 schedCancel(sched_task_t * __restrict task)	Line 685 schedCancel(sched_task_t * __restrict task)
* @root = root task	* @root = root task
* @type = cancel from queue type, if =taskMAX 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 = find task by criteria
* [CRITERIA_ANY\|CRITERIA_CALL\|CRITERIA_ARG\|CRITERIA_FD\|CRITERIA_VAL\|CRITERIA_ID\|CRITERIA_TS\|CRITERIA_DATA]	* [ CRITERIA_ANY\|CRITERIA_CALL\|CRITERIA_ARG\|CRITERIA_FD\|CRITERIA_VAL\|
	* CRITERIA_ID\|CRITERIA_TS\|CRITERIA_DATA\|CRITERIA_DATLEN ]
* @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, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok	* return: -1 error, -2 error in sub-stage cancel execution, -3 error from custom hook or 0 ok
Line 442 schedCancelby(sched_root_task_t * __restrict root, sch	Line 711 schedCancelby(sched_root_task_t * __restrict root, sch
return -2;	return -2;
if (schedCancelby(root, taskALARM, criteria, param, hook))	if (schedCancelby(root, taskALARM, criteria, param, hook))
return -2;	return -2;
	if (schedCancelby(root, taskRTC, criteria, param, hook))
	return -2;
if (schedCancelby(root, taskNODE, criteria, param, hook))	if (schedCancelby(root, taskNODE, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, taskPROC, criteria, param, hook))	if (schedCancelby(root, taskPROC, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, taskUSER, criteria, param, hook))
return -2;
if (schedCancelby(root, taskSIGNAL, criteria, param, hook))	if (schedCancelby(root, taskSIGNAL, criteria, param, hook))
return -2;	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))	if (schedCancelby(root, taskEVENT, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, taskEVENTLO, criteria, param, hook))	if (schedCancelby(root, taskTASK, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, taskSUSPEND, criteria, param, hook))	if (schedCancelby(root, taskSUSPEND, criteria, param, hook))
return -2;	return -2;
if (schedCancelby(root, taskREADY, criteria, param, hook))	if (schedCancelby(root, taskREADY, criteria, param, hook))
return -2;	return -2;
	if (schedCancelby(root, taskTHREAD, criteria, param, hook))
	return -2;
return 0;	return 0;
}	}
/* choosen queue */	/* choosen queue */
Line 474 schedCancelby(sched_root_task_t * __restrict root, sch	Line 751 schedCancelby(sched_root_task_t * __restrict root, sch
case taskALARM:	case taskALARM:
queue = &root->root_alarm;	queue = &root->root_alarm;
break;	break;
	case taskRTC:
	queue = &root->root_rtc;
	break;
case taskNODE:	case taskNODE:
queue = &root->root_node;	queue = &root->root_node;
break;	break;
case taskPROC:	case taskPROC:
queue = &root->root_proc;	queue = &root->root_proc;
break;	break;
case taskUSER:
queue = &root->root_user;
break;
case taskSIGNAL:	case taskSIGNAL:
queue = &root->root_signal;	queue = &root->root_signal;
break;	break;
	case taskAIO:
	queue = &root->root_aio;
	break;
	case taskLIO:
	queue = &root->root_lio;
	break;
	case taskUSER:
	queue = &root->root_user;
	break;
case taskEVENT:	case taskEVENT:
queue = &root->root_event;	queue = &root->root_event;
break;	break;
case taskEVENTLO:	case taskTASK:
queue = &root->root_eventlo;	queue = &root->root_task;
break;	break;
case taskSUSPEND:	case taskSUSPEND:
queue = &root->root_suspend;	queue = &root->root_suspend;
Line 498 schedCancelby(sched_root_task_t * __restrict root, sch	Line 784 schedCancelby(sched_root_task_t * __restrict root, sch
case taskREADY:	case taskREADY:
queue = &root->root_ready;	queue = &root->root_ready;
break;	break;
	case taskTHREAD:
	queue = &root->root_thread;
	break;
default:	default:
return 0;	return 0;
}	}
Line 536 schedCancelby(sched_root_task_t * __restrict root, sch	Line 825 schedCancelby(sched_root_task_t * __restrict root, sch
if (TASK_DATA(task) == param)	if (TASK_DATA(task) == param)
flg = 1;	flg = 1;
break;	break;
	case CRITERIA_DATLEN:
	if (TASK_DATLEN(task) == (size_t) param)
	flg = 1;
	break;
default:	default:
sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria);	sched_SetErr(EINVAL, "Invalid parameter criteria %d", criteria);
flg = -1;	flg = -1;
Line 558 schedCancelby(sched_root_task_t * __restrict root, sch	Line 851 schedCancelby(sched_root_task_t * __restrict root, sch

TAILQ_REMOVE(queue, task, task_node);	TAILQ_REMOVE(queue, task, task_node);
if (TASK_TYPE(task) != taskUNUSE)	if (TASK_TYPE(task) != taskUNUSE)
_sched_unuseTask(task);	sched_unuseTask(task);

flg ^= flg; /* ok */	flg ^= flg; /* ok */
}	}
Line 595 schedRun(sched_root_task_t root, volatile intptr_t	Line 888 schedRun(sched_root_task_t root, volatile intptr_t
root->root_hooks.hook_exec.condition &&	root->root_hooks.hook_exec.condition &&
root->root_hooks.hook_exec.condition(root, (void*) killState)) {	root->root_hooks.hook_exec.condition(root, (void*) killState)) {
if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
schedCall(task);	root->root_ret = schedCall(task);
}	}
else	else
/* trigger scheduler loop */	/* trigger scheduler loop */
while (!*killState && root && root->root_hooks.hook_exec.fetch) {	while (!*killState && root && root->root_hooks.hook_exec.fetch) {
if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
schedCall(task);	root->root_ret = schedCall(task);
}	}
} else	} else
/* infinite scheduler loop */	/* infinite scheduler loop */
while (root && root->root_hooks.hook_exec.fetch)	while (root && root->root_hooks.hook_exec.fetch)
if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))	if ((task = root->root_hooks.hook_exec.fetch(root, NULL)))
schedCall(task);	root->root_ret = schedCall(task);

return 0;	return 0;
}	}
Line 620 schedRun(sched_root_task_t root, volatile intptr_t	Line 913 schedRun(sched_root_task_t root, volatile intptr_t
* @tsold = old timeout polling if !=NULL	* @tsold = old timeout polling if !=NULL
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
inline int	int
schedPolling(sched_root_task_t * __restrict root, struct timespec * __restrict ts,	schedPolling(sched_root_task_t * __restrict root, struct timespec * __restrict ts,
struct timespec * __restrict tsold)	struct timespec * __restrict tsold)
{	{
Line 643 schedPolling(sched_root_task_t * __restrict root, stru	Line 936 schedPolling(sched_root_task_t * __restrict root, stru
*	*
* @root = root task	* @root = root task
* @condValue = condition value, kill schedRun() if condValue == killState	* @condValue = condition value, kill schedRun() if condValue == killState
* return: -1 error ok 0 ok	* return: -1 error or 0 ok
*/	*/
inline int	int
schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue)	schedTermCondition(sched_root_task_t * __restrict root, intptr_t condValue)
{	{
if (!root)	if (!root)
Line 661 schedTermCondition(sched_root_task_t * __restrict root	Line 954 schedTermCondition(sched_root_task_t * __restrict root
*	*
* @root = root task	* @root = root task
* @criteria = find task by criteria	* @criteria = find task by criteria
* [CRITERIA_ANY\|CRITERIA_ID\|CRITERIA_DATA]	* [CRITERIA_ANY\|CRITERIA_ID\|CRITERIA_VAL\|CRITERIA_DATA]
* @param = search parameter (sched_task_t *task\| u_long id)	* @param = search parameter (sched_task_t *task\| unsigned long id)
* return: -1 error or 0 resumed ok	* return: -1 error or 0 resumed ok
*/	*/
int	int
Line 684 schedResumeby(sched_root_task_t * __restrict root, u_c	Line 977 schedResumeby(sched_root_task_t * __restrict root, u_c
flg = 1;	flg = 1;
break;	break;
case CRITERIA_ID:	case CRITERIA_ID:
	case CRITERIA_VAL:
if (TASK_VAL(task) == (u_long) param)	if (TASK_VAL(task) == (u_long) param)
flg = 1;	flg = 1;
break;	break;

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

Removed from v.1.10.6.1
changed lines
	Added in v.1.24.4.1