libaitsched/src/tasks.c - diff

Return to tasks.c CVS log

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

Diff for /libaitsched/src/tasks.c between versions 1.23 and 1.25.2.1

version 1.23, 2014/01/28 13:17:33	version 1.25.2.1, 2015/07/02 22:38:28
Line 57 sched_useTask(sched_root_task_t * __restrict root)	Line 57 sched_useTask(sched_root_task_t * __restrict root)
{	{
sched_task_t task, tmp;	sched_task_t task, tmp;

#ifdef HAVE_LIBPTHREAD	SCHED_QLOCK(root, taskUNUSE);
pthread_mutex_lock(&root->root_mtx[taskUNUSE]);
#endif
TAILQ_FOREACH_SAFE(task, &root->root_unuse, task_node, tmp) {	TAILQ_FOREACH_SAFE(task, &root->root_unuse, task_node, tmp) {
if (!TASK_ISLOCKED(task)) {	if (!TASK_ISLOCKED(task)) {
TAILQ_REMOVE(&root->root_unuse, task, task_node);	TAILQ_REMOVE(&root->root_unuse, task, task_node);
break;	break;
}	}
}	}
#ifdef HAVE_LIBPTHREAD	SCHED_QUNLOCK(root, taskUNUSE);
pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);
#endif

if (!task) {	if (!task) {
task = malloc(sizeof(sched_task_t));	task = malloc(sizeof(sched_task_t));
Line 93 sched_task_t *	Line 89 sched_task_t *
sched_unuseTask(sched_task_t * __restrict task)	sched_unuseTask(sched_task_t * __restrict task)
{	{
TASK_UNLOCK(task);	TASK_UNLOCK(task);

TASK_TYPE(task) = taskUNUSE;	TASK_TYPE(task) = taskUNUSE;
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &(TASK_ROOT(task))->root_unuse);
pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
#endif
TAILQ_INSERT_TAIL(&TASK_ROOT(task)->root_unuse, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
#endif
task = NULL;

	task = NULL;
return task;	return task;
}	}

#pragma GCC visibility push(hidden)

#ifdef HAVE_LIBPTHREAD
static void
_sched_threadCleanup(sched_task_t *t)
{
if (!t \|\| !TASK_ROOT(t))
return;

pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);
pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
sched_unuseTask(t);
}
void *
_sched_threadWrapper(sched_task_t *t)
{
void *ret = NULL;

pthread_cleanup_push((void ()(void)) _sched_threadCleanup, t);

if (!t \|\| !TASK_ROOT(t))
pthread_exit(ret);

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
/*
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
*/

/* notify parent, thread is ready for execution */
pthread_testcancel();

ret = schedCall(t);

pthread_cleanup_pop(42);
TASK_ROOT(t)->root_ret = ret;
pthread_exit(ret);
}
#endif

#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
void *
_sched_rtcWrapper(sched_task_t *t)
{
sched_task_func_t func;
sched_task_t *task;
sched_root_task_t *r;

if (!t \|\| !TASK_ROOT(t) \|\| !TASK_DATA(t))
return NULL;
else {
r = TASK_ROOT(t);
task = (sched_task_t*) TASK_DATA(t);
func = TASK_FUNC(task);
}

#ifdef HAVE_LIBPTHREAD
pthread_mutex_lock(&r->root_mtx[taskRTC]);
#endif
TAILQ_REMOVE(&r->root_rtc, task, task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&r->root_mtx[taskRTC]);
#endif
sched_unuseTask(task);

timer_delete((timer_t) TASK_DATLEN(t));

return schedCall(task);
}
#endif

#pragma GCC visibility pop

/*	/*
* sched_taskExit() - Exit routine for scheduler task, explicit required for thread tasks	* sched_taskExit() - Exit routine for scheduler task, explicit required for thread tasks
*	*
Line 225 schedRead(sched_root_task_t * __restrict root, sched_t	Line 143 schedRead(sched_root_task_t * __restrict root, sched_t
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskREAD;	TASK_TYPE(task) = taskREAD;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 240 schedRead(sched_root_task_t * __restrict root, sched_t	Line 158 schedRead(sched_root_task_t * __restrict root, sched_t
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_read);
pthread_mutex_lock(&root->root_mtx[taskREAD]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_read, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskREAD]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
Line 279 schedWrite(sched_root_task_t * __restrict root, sched_	Line 191 schedWrite(sched_root_task_t * __restrict root, sched_
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskWRITE;	TASK_TYPE(task) = taskWRITE;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 294 schedWrite(sched_root_task_t * __restrict root, sched_	Line 206 schedWrite(sched_root_task_t * __restrict root, sched_
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_write);
pthread_mutex_lock(&root->root_mtx[taskWRITE]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_write, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskWRITE]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
Line 323 sched_task_t *	Line 229 sched_task_t *
schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 337 schedNode(sched_root_task_t * __restrict root, sched_t	Line 243 schedNode(sched_root_task_t * __restrict root, sched_t
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskNODE;	TASK_TYPE(task) = taskNODE;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 352 schedNode(sched_root_task_t * __restrict root, sched_t	Line 258 schedNode(sched_root_task_t * __restrict root, sched_t
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_node);
pthread_mutex_lock(&root->root_mtx[taskNODE]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_node, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskNODE]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 382 sched_task_t *	Line 282 sched_task_t *
schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid,	schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 396 schedProc(sched_root_task_t * __restrict root, sched_t	Line 296 schedProc(sched_root_task_t * __restrict root, sched_t
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskPROC;	TASK_TYPE(task) = taskPROC;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 411 schedProc(sched_root_task_t * __restrict root, sched_t	Line 311 schedProc(sched_root_task_t * __restrict root, sched_t
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_proc);
pthread_mutex_lock(&root->root_mtx[taskPROC]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_proc, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskPROC]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 441 sched_task_t *	Line 335 sched_task_t *
schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id,	schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 459 schedUser(sched_root_task_t * __restrict root, sched_t	Line 353 schedUser(sched_root_task_t * __restrict root, sched_t
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskUSER;	TASK_TYPE(task) = taskUSER;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 474 schedUser(sched_root_task_t * __restrict root, sched_t	Line 368 schedUser(sched_root_task_t * __restrict root, sched_t
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_user);
pthread_mutex_lock(&root->root_mtx[taskUSER]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_user, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskUSER]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* EVFILT_USER */	#endif /* EVFILT_USER */
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 505 sched_task_t *	Line 393 sched_task_t *
schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig,	schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 519 schedSignal(sched_root_task_t * __restrict root, sched	Line 407 schedSignal(sched_root_task_t * __restrict root, sched
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskSIGNAL;	TASK_TYPE(task) = taskSIGNAL;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 534 schedSignal(sched_root_task_t * __restrict root, sched	Line 422 schedSignal(sched_root_task_t * __restrict root, sched
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_signal);
pthread_mutex_lock(&root->root_mtx[taskSIGNAL]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_signal, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskSIGNAL]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 564 sched_task_t *	Line 446 sched_task_t *
schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,	schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 578 schedAlarm(sched_root_task_t * __restrict root, sched_	Line 460 schedAlarm(sched_root_task_t * __restrict root, sched_
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskALARM;	TASK_TYPE(task) = taskALARM;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 593 schedAlarm(sched_root_task_t * __restrict root, sched_	Line 475 schedAlarm(sched_root_task_t * __restrict root, sched_
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_alarm);
pthread_mutex_lock(&root->root_mtx[taskALARM]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_alarm, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskALARM]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

#ifdef AIO_SUPPORT	#ifdef AIO_SUPPORT
Line 624 sched_task_t *	Line 500 sched_task_t *
schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,	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)	struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 638 schedAIO(sched_root_task_t * __restrict root, sched_ta	Line 514 schedAIO(sched_root_task_t * __restrict root, sched_ta
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskAIO;	TASK_TYPE(task) = taskAIO;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 653 schedAIO(sched_root_task_t * __restrict root, sched_ta	Line 529 schedAIO(sched_root_task_t * __restrict root, sched_ta
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_aio);
pthread_mutex_lock(&root->root_mtx[taskAIO]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_aio, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskAIO]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 684 sched_task_t *	Line 554 sched_task_t *
schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *buffer, size_t buflen, off_t offset)	void *buffer, size_t buflen, off_t offset)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 724 schedAIORead(sched_root_task_t * __restrict root, sche	Line 594 schedAIORead(sched_root_task_t * __restrict root, sche
}	}

return schedAIO(root, func, arg, acb, buffer, buflen);	return schedAIO(root, func, arg, acb, buffer, buflen);
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 743 sched_task_t *	Line 613 sched_task_t *
schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,
void *buffer, size_t buflen, off_t offset)	void *buffer, size_t buflen, off_t offset)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 783 schedAIOWrite(sched_root_task_t * __restrict root, sch	Line 653 schedAIOWrite(sched_root_task_t * __restrict root, sch
}	}

return schedAIO(root, func, arg, acb, buffer, buflen);	return schedAIO(root, func, arg, acb, buffer, buflen);
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

#ifdef EVFILT_LIO	#ifdef EVFILT_LIO
Line 802 sched_task_t *	Line 672 sched_task_t *
schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,	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)	struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 816 schedLIO(sched_root_task_t * __restrict root, sched_ta	Line 686 schedLIO(sched_root_task_t * __restrict root, sched_ta
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskLIO;	TASK_TYPE(task) = taskLIO;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 831 schedLIO(sched_root_task_t * __restrict root, sched_ta	Line 701 schedLIO(sched_root_task_t * __restrict root, sched_ta
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_lio);
pthread_mutex_lock(&root->root_mtx[taskLIO]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_lio, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskLIO]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 862 sched_task_t *	Line 726 sched_task_t *
schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	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)	struct iovec *bufs, size_t nbufs, off_t offset)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 920 schedLIORead(sched_root_task_t * __restrict root, sche	Line 784 schedLIORead(sched_root_task_t * __restrict root, sche
}	}

return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);	return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}

/*	/*
Line 939 sched_task_t *	Line 803 sched_task_t *
schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,	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)	struct iovec *bufs, size_t nbufs, off_t offset)
{	{
#ifdef KQ_DISABLE	#if SUP_ENABLE != KQ_SUPPORT
sched_SetErr(ENOTSUP, "disabled kqueue support");	sched_SetErr(ENOTSUP, "disabled kqueue support");
return NULL;	return NULL;
#else	#else
Line 997 schedLIOWrite(sched_root_task_t * __restrict root, sch	Line 861 schedLIOWrite(sched_root_task_t * __restrict root, sch
}	}

return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);	return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
#endif /* KQ_DISABLE */	#endif /* KQ_SUPPORT */
}	}
#endif /* EVFILT_LIO */	#endif /* EVFILT_LIO */
#endif /* AIO_SUPPORT */	#endif /* AIO_SUPPORT */
Line 1028 schedTimer(sched_root_task_t * __restrict root, sched_	Line 892 schedTimer(sched_root_task_t * __restrict root, sched_
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskTIMER;	TASK_TYPE(task) = taskTIMER;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1056 schedTimer(sched_root_task_t * __restrict root, sched_	Line 920 schedTimer(sched_root_task_t * __restrict root, sched_
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr) {
#ifdef HAVE_LIBPTHREAD	SCHED_QLOCK(root, taskTIMER);
pthread_mutex_lock(&root->root_mtx[taskTIMER]);
#endif
#ifdef TIMER_WITHOUT_SORT	#ifdef TIMER_WITHOUT_SORT
TAILQ_INSERT_TAIL(&root->root_timer, TASK_ID(task), task_node);	TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
#else	#else
TAILQ_FOREACH_SAFE(t, &root->root_timer, task_node, tmp)	TAILQ_FOREACH_SAFE(t, &root->root_timer, task_node, tmp)
if (sched_timespeccmp(&TASK_TS(task), &TASK_TS(t), -) < 1)	if (sched_timespeccmp(&TASK_TS(task), &TASK_TS(t), -) < 1)
break;	break;
if (!t)	if (!t)
TAILQ_INSERT_TAIL(&root->root_timer, TASK_ID(task), task_node);	TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
else	else
TAILQ_INSERT_BEFORE(t, TASK_ID(task), task_node);	TAILQ_INSERT_BEFORE(t, task, task_node);
#endif	#endif
#ifdef HAVE_LIBPTHREAD	SCHED_QUNLOCK(root, taskTIMER);
pthread_mutex_unlock(&root->root_mtx[taskTIMER]);
#endif
} else	} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

Line 1104 schedEvent(sched_root_task_t * __restrict root, sched_	Line 964 schedEvent(sched_root_task_t * __restrict root, sched_
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskEVENT;	TASK_TYPE(task) = taskEVENT;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1119 schedEvent(sched_root_task_t * __restrict root, sched_	Line 979 schedEvent(sched_root_task_t * __restrict root, sched_
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_event);
pthread_mutex_lock(&root->root_mtx[taskEVENT]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_event, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskEVENT]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
Line 1159 schedTask(sched_root_task_t * __restrict root, sched_t	Line 1013 schedTask(sched_root_task_t * __restrict root, sched_t
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskTASK;	TASK_TYPE(task) = taskTASK;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1175 schedTask(sched_root_task_t * __restrict root, sched_t	Line 1029 schedTask(sched_root_task_t * __restrict root, sched_t
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr) {
#ifdef HAVE_LIBPTHREAD	SCHED_QLOCK(root, taskTASK);
pthread_mutex_lock(&root->root_mtx[taskTASK]);
#endif
TAILQ_FOREACH_SAFE(t, &root->root_task, task_node, tmp)	TAILQ_FOREACH_SAFE(t, &root->root_task, task_node, tmp)
if (TASK_VAL(task) < TASK_VAL(t))	if (TASK_VAL(task) < TASK_VAL(t))
break;	break;
if (!t)	if (!t)
TAILQ_INSERT_TAIL(&root->root_task, TASK_ID(task), task_node);	TAILQ_INSERT_TAIL(&root->root_task, task, task_node);
else	else
TAILQ_INSERT_BEFORE(t, TASK_ID(task), task_node);	TAILQ_INSERT_BEFORE(t, task, task_node);
#ifdef HAVE_LIBPTHREAD	SCHED_QUNLOCK(root, taskTASK);
pthread_mutex_unlock(&root->root_mtx[taskTASK]);
#endif
} else	} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

Line 1219 schedSuspend(sched_root_task_t * __restrict root, sche	Line 1069 schedSuspend(sched_root_task_t * __restrict root, sche
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskSUSPEND;	TASK_TYPE(task) = taskSUSPEND;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1234 schedSuspend(sched_root_task_t * __restrict root, sche	Line 1084 schedSuspend(sched_root_task_t * __restrict root, sche
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_suspend);
pthread_mutex_lock(&root->root_mtx[taskSUSPEND]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_suspend, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskSUSPEND]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;
Line 1273 schedCallOnce(sched_root_task_t * __restrict root, sch	Line 1117 schedCallOnce(sched_root_task_t * __restrict root, sch
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskEVENT;	TASK_TYPE(task) = taskEVENT;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1310 schedThread(sched_root_task_t * __restrict root, sched	Line 1154 schedThread(sched_root_task_t * __restrict root, sched
#endif	#endif
sched_task_t *task;	sched_task_t *task;
pthread_attr_t attr;	pthread_attr_t attr;
	void *ptr;

if (!root \|\| !func)	if (!root \|\| !func)
return NULL;	return NULL;

/* get new task */	/* get new task */
if (!(task = sched_useTask(root))) {	if (!(task = sched_useTask(root)))

return NULL;	return NULL;
}

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskTHREAD;	TASK_TYPE(task) = taskTHREAD;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1330 schedThread(sched_root_task_t * __restrict root, sched	Line 1173 schedThread(sched_root_task_t * __restrict root, sched
TASK_DATLEN(task) = opt_dlen;	TASK_DATLEN(task) = opt_dlen;

pthread_attr_init(&attr);	pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_DETACHED);	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {	if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {
LOGERR;	LOGERR;
pthread_attr_destroy(&attr);	pthread_attr_destroy(&attr);
Line 1342 schedThread(sched_root_task_t * __restrict root, sched	Line 1185 schedThread(sched_root_task_t * __restrict root, sched
return sched_unuseTask(task);	return sched_unuseTask(task);
} else	} else
TASK_FLAG(task) = ss;	TASK_FLAG(task) = ss;
if ((errno = pthread_attr_setguardsize(&attr, ss))) {
LOGERR;
pthread_attr_destroy(&attr);
return sched_unuseTask(task);
}
#ifdef SCHED_RR	#ifdef SCHED_RR
pthread_attr_setschedpolicy(&attr, SCHED_RR);	pthread_attr_setschedpolicy(&attr, SCHED_RR);
#else	#else
pthread_attr_setschedpolicy(&attr, SCHED_OTHER);	pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
#endif	#endif

pthread_mutex_lock(&root->root_mtx[taskTHREAD]);
TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);
pthread_mutex_unlock(&root->root_mtx[taskTHREAD]);

if (root->root_hooks.hook_add.thread)	if (root->root_hooks.hook_add.thread)
if (root->root_hooks.hook_add.thread(task, &attr)) {	ptr = root->root_hooks.hook_add.thread(task, &attr);
schedCancel(task);	else
task = NULL;	ptr = NULL;
}
	if (!ptr)
	insert_task_to(task, &root->root_thread);
	else
	task = sched_unuseTask(task);

pthread_attr_destroy(&attr);	pthread_attr_destroy(&attr);
return task;	return task;
}	}
Line 1381 sched_task_t *	Line 1221 sched_task_t *
schedRTC(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,	schedRTC(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,
void *opt_data, size_t opt_dlen)	void *opt_data, size_t opt_dlen)
{	{
#if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)	#if defined(HAVE_LIBRT) && defined(HAVE_TIMER_CREATE) && \
	defined(HAVE_TIMER_SETTIME) && defined(HAVE_TIMER_DELETE)
sched_task_t *task;	sched_task_t *task;
void *ptr;	void *ptr;

Line 1392 schedRTC(sched_root_task_t * __restrict root, sched_ta	Line 1233 schedRTC(sched_root_task_t * __restrict root, sched_ta
if (!(task = sched_useTask(root)))	if (!(task = sched_useTask(root)))
return NULL;	return NULL;

task->task_func = func;	TASK_FUNC(task) = func;
TASK_TYPE(task) = taskRTC;	TASK_TYPE(task) = taskRTC;
TASK_ROOT(task) = root;	TASK_ROOT(task) = root;

Line 1407 schedRTC(sched_root_task_t * __restrict root, sched_ta	Line 1248 schedRTC(sched_root_task_t * __restrict root, sched_ta
else	else
ptr = NULL;	ptr = NULL;

if (!ptr) {	if (!ptr)
#ifdef HAVE_LIBPTHREAD	insert_task_to(task, &root->root_rtc);
pthread_mutex_lock(&root->root_mtx[taskRTC]);	else
#endif
TAILQ_INSERT_TAIL(&root->root_rtc, TASK_ID(task), task_node);
#ifdef HAVE_LIBPTHREAD
pthread_mutex_unlock(&root->root_mtx[taskRTC]);
#endif
} else
task = sched_unuseTask(task);	task = sched_unuseTask(task);

return task;	return task;

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

Removed from v.1.23
changed lines
	Added in v.1.25.2.1