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.28.14.1 and 1.34.2.1

version 1.28.14.1, 2022/10/03 22:16:36	version 1.34.2.1, 2023/08/31 15:25:59
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 - 2022	Copyright 2004 - 2023
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 181 schedRegisterHooks(sched_root_task_t * __restrict root	Line 181 schedRegisterHooks(sched_root_task_t * __restrict root
root->root_hooks.hook_add.alarm = sched_hook_alarm;	root->root_hooks.hook_add.alarm = sched_hook_alarm;
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;
#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
Line 189 schedRegisterHooks(sched_root_task_t * __restrict root	Line 188 schedRegisterHooks(sched_root_task_t * __restrict root
#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
root->root_hooks.hook_add.thread = sched_hook_thread;	root->root_hooks.hook_add.thread = sched_hook_thread;
#endif	#endif
	root->root_hooks.hook_add.signal = sched_hook_signal;

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 228 schedInit(void ** __restrict data, size_t datlen)	Line 228 schedInit(void ** __restrict data, size_t datlen)
sched_timespecinf(&root->root_poll);	sched_timespecinf(&root->root_poll);

#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
	if (pthread_mutex_init(&root->root_sigmtx, NULL)) {
	LOGERR;
	e_free(root);
	return NULL;
	}

for (i = 0; i < taskMAX; i++)	for (i = 0; i < taskMAX; i++)
if ((errno = pthread_mutex_init(&root->root_mtx[i], NULL))) {	if ((errno = pthread_mutex_init(&root->root_mtx[i], NULL))) {
LOGERR;	LOGERR;
Line 262 schedInit(void ** __restrict data, size_t datlen)	Line 268 schedInit(void ** __restrict data, size_t datlen)
#ifdef HAVE_LIBPTHREAD	#ifdef HAVE_LIBPTHREAD
for (i = 0; i < taskMAX; i++)	for (i = 0; i < taskMAX; i++)
pthread_mutex_unlock(&root->root_mtx[i]);	pthread_mutex_unlock(&root->root_mtx[i]);

	pthread_sigmask(SIG_BLOCK, NULL, &root->root_oldset);
	#else
	sigprocmask(SIG_BLOCK, NULL, &root->root_oldset);
#endif	#endif

if (data && *data) {	if (data && *data) {
Line 386 schedEnd(sched_root_task_t ** __restrict root)	Line 396 schedEnd(sched_root_task_t ** __restrict root)
SCHED_QUNLOCK(*root, i);	SCHED_QUNLOCK(*root, i);
pthread_mutex_destroy(&(*root)->root_mtx[i]);	pthread_mutex_destroy(&(*root)->root_mtx[i]);
}	}

	if ((*root)->root_sigthr) {
	pthread_cancel((*root)->root_sigthr);
	#ifdef __linux__
	(*root)->root_sigthr = 0L;
	#else
	(*root)->root_sigthr = NULL;
#endif	#endif
	pthread_sigmask(SIG_SETMASK, &(*root)->root_oldset, NULL);
	pthread_mutex_unlock(&(*root)->root_sigmtx);
	}
	pthread_mutex_destroy(&(*root)->root_sigmtx);
	#else
	sigprocmask(SIG_SETMASK, &(*root)->root_oldset, NULL);
	#endif

e_free(*root);	e_free(*root);
*root = NULL;	*root = NULL;
Line 560 schedQuery(sched_task_t * __restrict task)	Line 584 schedQuery(sched_task_t * __restrict task)
* [ CRITERIA_ANY\|CRITERIA_CALL\|CRITERIA_ARG\|CRITERIA_FD\|CRITERIA_VAL\|	* [ CRITERIA_ANY\|CRITERIA_CALL\|CRITERIA_ARG\|CRITERIA_FD\|CRITERIA_VAL\|
* CRITERIA_ID\|CRITERIA_TS\|CRITERIA_DATA\|CRITERIA_DATLEN ]	* CRITERIA_ID\|CRITERIA_TS\|CRITERIA_DATA\|CRITERIA_DATLEN ]
* @param = search parameter	* @param = search parameter
* return: -1 error, 0 found or 1 not found	* return: NULL not found or !=NULL task
*/	*/
int	sched_task_t *
schedQueryby(sched_root_task_t * __restrict root, sched_task_type_t type,	schedQueryby(sched_root_task_t * __restrict root, sched_task_type_t type,
u_char criteria, void *param)	u_char criteria, void *param)
{	{
sched_task_t *task;	sched_task_t *task;
sched_queue_t *queue;	sched_queue_t *queue;
register int flg = 0;

if (!root)	if (!root)
return -1;	return NULL;
/* if type == taskMAX check in all queues */	/* if type == taskMAX check in all queues */
if (type == taskMAX) {	if (type == taskMAX) {
if ((flg = schedQueryby(root, taskREAD, criteria, param)) < 1)	if ((task = schedQueryby(root, taskREAD, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskWRITE, criteria, param)) < 1)	if ((task = schedQueryby(root, taskWRITE, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskTIMER, criteria, param)) < 1)	if ((task = schedQueryby(root, taskTIMER, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskALARM, criteria, param)) < 1)	if ((task = schedQueryby(root, taskALARM, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskRTC, criteria, param)) < 1)	if ((task = schedQueryby(root, taskRTC, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskNODE, criteria, param)) < 1)	if ((task = schedQueryby(root, taskNODE, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskPROC, criteria, param)) < 1)	if ((task = schedQueryby(root, taskPROC, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskSIGNAL, criteria, param)) < 1)	if ((task = schedQueryby(root, taskSIGNAL, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskAIO, criteria, param)) < 1)	if ((task = schedQueryby(root, taskAIO, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskLIO, criteria, param)) < 1)	if ((task = schedQueryby(root, taskLIO, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskUSER, criteria, param)) < 1)	if ((task = schedQueryby(root, taskUSER, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskEVENT, criteria, param)) < 1)	if ((task = schedQueryby(root, taskEVENT, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskTASK, criteria, param)) < 1)	if ((task = schedQueryby(root, taskTASK, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskSUSPEND, criteria, param)) < 1)	if ((task = schedQueryby(root, taskSUSPEND, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskREADY, criteria, param)) < 1)	if ((task = schedQueryby(root, taskREADY, criteria, param)))
return flg;	return task;
if ((flg = schedQueryby(root, taskTHREAD, criteria, param)) < 1)	if ((task = schedQueryby(root, taskTHREAD, criteria, param)))
return flg;	return task;
return 1; /* not found */	return NULL; /* not found */
}	}
/* choosen queue */	/* choosen queue */
switch (type) {	switch (type) {
Line 659 schedQueryby(sched_root_task_t * __restrict root, sche	Line 682 schedQueryby(sched_root_task_t * __restrict root, sche
queue = &root->root_thread;	queue = &root->root_thread;
break;	break;
default:	default:
return 1; /* not found */	return NULL; /* not found */
}	}

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

return 1; /* not found */	return NULL; /* not found */
}	}

/*	/*
Line 1110 schedResumeby(sched_root_task_t * __restrict root, u_c	Line 1133 schedResumeby(sched_root_task_t * __restrict root, u_c
SCHED_QUNLOCK(root, taskSUSPEND);	SCHED_QUNLOCK(root, taskSUSPEND);

return flg;	return flg;
	}

	static void *
	_sched_sigDisp(void *arg)
	{
	sched_root_task_t *root = arg;
	sched_task_t task, tmp;
	int sig, flg;
	sigset_t ss;

	sigfillset(&ss);
	while (root->root_sigthr) {
	if (sigwait(&ss, &sig))
	continue;

	pthread_mutex_lock(&root->root_sigmtx);
	if (!sigismember(&root->root_sigset, sig)) {
	pthread_mutex_unlock(&root->root_sigmtx);
	continue;
	}

	flg = 0;
	TAILQ_FOREACH_SAFE(task, &root->root_signal, task_node, tmp) {
	if (TASK_VAL(task) == (uintptr_t) sig) {
	if (!flg) {
	TASK_RET(task) = 0;
	TASK_FLAG(task) = 0;

	/* remove signal handle */
	transit_task2ready(task, &root->root_signal);
	}
	flg++;
	}
	}
	if (flg < 2)
	sigdelset(&root->root_sigset, sig);

	pthread_mutex_unlock(&root->root_sigmtx);
	}

	return NULL;
	}

	/*
	* schedSignalDispatch() - Activate or Deactivate signal dispatcher
	*
	* @root = root task
	* @on = Activate or =0 deactivate
	* return: -1 error or 0 ok
	*/
	int
	schedSignalDispatch(sched_root_task_t * __restrict root, int on)
	{
	sigset_t ss;
	struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 };
	#ifndef HAVE_LIBPTHREAD
	sched_SetErr(ENOTSUP, "Library has not support pthreads");
	return -1;
	#else
	pthread_attr_t attr;
	#endif

	#if SUP_ENABLE == KQ_SUPPORT
	return 0;
	#endif

	if (!on) {
	pthread_cancel(root->root_sigthr);
	#ifdef __linux__
	root->root_sigthr = 0L;
	#else
	root->root_sigthr = NULL;
	#endif
	return 0;
	}

	/* if we have not using polling, then we must turn on */
	if (sched_timespecisinf(&root->root_poll))
	schedPolling(root, &ts, NULL);

	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	#ifdef SCHED_RR
	pthread_attr_setschedpolicy(&attr, SCHED_RR);
	#else
	pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
	#endif

	sigfillset(&ss);
	pthread_sigmask(SIG_BLOCK, &ss, NULL);

	if (pthread_create(&root->root_sigthr, &attr, _sched_sigDisp, root)) {
	sched_SetErr(errno, "pthread_create(SignalDispatch) #%d - %s",
	errno, strerror(errno));
	#ifdef __linux__
	root->root_sigthr = 0L;
	#else
	root->root_sigthr = NULL;
	#endif
	pthread_sigmask(SIG_SETMASK, &root->root_oldset, NULL);
	return -1;
	}

	return 0;
}	}

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

Removed from v.1.28.14.1
changed lines
	Added in v.1.34.2.1