static int rtswitch_create_ktask(rtswitch_context_t *ctx,
struct rttst_swtest_task *ptask)
{
rtswitch_task_t *task;
xnflags_t init_flags;
struct taskarg arg;
char name[30];
int err;
ptask->flags |= RTSWITCH_KERNEL;
err = rtswitch_register_task(ctx, ptask);
if (err)
return err;
snprintf(name, sizeof(name), "rtk%d/%u", ptask->index, ctx->cpu);
task = &ctx->tasks[ptask->index];
arg.ctx = ctx;
arg.task = task;
init_flags = (ptask->flags & RTTST_SWTEST_FPU) ? XNFPU : 0;
/* Migrate the calling thread to the same CPU as the created task, in
order to be sure that the created task is suspended when this function
returns. This also allow us to use the stack to pass the parameters to
the created task. */
set_cpus_allowed(current, cpumask_of_cpu(ctx->cpu));
err = xnpod_init_thread(&task->ktask, rtdm_tbase, name, 1, init_flags, 0, NULL);
if (!err)
err = xnpod_start_thread(&task->ktask,
0,
0,
xnarch_cpumask_of_cpu(ctx->cpu),
rtswitch_ktask,
&arg);
else
/* In order to avoid calling xnpod_delete_thread with invalid
thread. */
task->base.flags = 0;
/* Putting the argument on stack is safe, because the new thread will
preempt the current thread immediately, and will suspend only once the
arguments on stack are used. */
return err;
}
u_long t_start(u_long tid,
u_long mode,
void (*startaddr) (u_long, u_long, u_long, u_long),
u_long targs[])
{
struct xnthread_start_attr attr;
u_long err = SUCCESS;
xnflags_t xnmode;
psostask_t *task;
spl_t s;
/* We have no error case here: just clear out any unwanted bit. */
mode &= ~T_START_MASK;
xnlock_get_irqsave(&nklock, s);
task = psos_h2obj_active(tid, PSOS_TASK_MAGIC, psostask_t);
if (!task) {
err = psos_handle_error(tid, PSOS_TASK_MAGIC, psostask_t);
goto unlock_and_exit;
}
if (!xnthread_test_state(&task->threadbase, XNDORMANT)) {
err = ERR_ACTIVE; /* Task already started */
goto unlock_and_exit;
}
xnmode = psos_mode_to_xeno(mode);
if (xnmode & XNRRB) {
xnpod_set_thread_tslice(&task->threadbase, psos_time_slice);
xnmode &= ~XNRRB;
}
task->entry = startaddr;
attr.mode = xnmode;
attr.imask = (int)((mode >> 8) & 0x7);
attr.affinity = XNPOD_ALL_CPUS;
if (targs)
memcpy(task->args, targs, sizeof(task->args));
else
memset(task->args, 0, sizeof(task->args));
#ifdef CONFIG_XENO_OPT_PERVASIVE
if (xnthread_test_state(&task->threadbase, XNSHADOW)) {
attr.entry = (void (*)(void *))startaddr;
attr.cookie = (void *)xnthread_handle(&task->threadbase);
} else
#endif /* CONFIG_XENO_OPT_PERVASIVE */
{
attr.entry = psostask_trampoline;
attr.cookie = task;
}
xnpod_start_thread(&task->threadbase, &attr);
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
return err;
}
int rt_task_init(RT_TASK *task,
void (*body) (int),
int cookie,
int stack_size,
int priority, int uses_fpu, void (*sigfn) (void))
{
union xnsched_policy_param param;
struct xnthread_start_attr sattr;
struct xnthread_init_attr iattr;
xnflags_t bflags = 0;
int ret;
spl_t s;
if (priority < XNSCHED_LOW_PRIO ||
priority > XNSCHED_HIGH_PRIO || task->magic == RTAI_TASK_MAGIC)
return -EINVAL;
priority = XNSCHED_HIGH_PRIO - priority + 1; /* Normalize. */
if (uses_fpu)
#ifdef CONFIG_XENO_HW_FPU
bflags |= XNFPU;
#else /* !CONFIG_XENO_HW_FPU */
return -EINVAL;
#endif /* CONFIG_XENO_HW_FPU */
iattr.tbase = rtai_tbase;
iattr.name = NULL;
iattr.flags = bflags;
iattr.ops = &__rtai_task_ops;
iattr.stacksize = stack_size;
param.rt.prio = priority;
if (xnpod_init_thread(&task->thread_base,
&iattr, &xnsched_class_rt, ¶m) != 0)
/* Assume this is the only possible failure. */
return -ENOMEM;
xnarch_cpus_clear(task->affinity);
inith(&task->link);
task->suspend_depth = 1;
task->cookie = cookie;
task->body = body;
task->sigfn = sigfn;
if (xnarch_cpus_empty(task->affinity))
task->affinity = XNPOD_ALL_CPUS;
xnlock_get_irqsave(&nklock, s);
sattr.mode = XNSUSP; /* Suspend on startup. */
sattr.imask = 0;
sattr.affinity = task->affinity;
sattr.entry = rt_task_trampoline;
sattr.cookie = task;
ret = xnpod_start_thread(&task->thread_base, &sattr);
if (ret)
goto unlock_and_exit;
task->magic = RTAI_TASK_MAGIC;
appendq(&__rtai_task_q, &task->link);
#ifdef CONFIG_XENO_FASTSYNCH
/* We need an anonymous registry entry to obtain a handle for fast
mutex locking. */
ret = xnthread_register(&task->thread_base, "");
if (ret) {
xnpod_abort_thread(&task->thread_base);
goto unlock_and_exit;
}
#endif /* CONFIG_XENO_FASTSYNCH */
/* Add a switch hook only if a signal function has been declared
at least once for some created task. */
if (sigfn != NULL && __rtai_task_sig++ == 0)
xnpod_add_hook(XNHOOK_THREAD_SWITCH, &__task_switch_hook);
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
return ret ? -EINVAL : 0;
}
static int rtswitch_create_ktask(rtswitch_context_t *ctx,
struct rttst_swtest_task *ptask)
{
union xnsched_policy_param param;
struct xnthread_start_attr sattr;
struct xnthread_init_attr iattr;
rtswitch_task_t *task;
xnflags_t init_flags;
struct taskarg arg;
char name[30];
int err;
/*
* Silently disable FP tests in kernel if FPU is not supported
* there. Typical case is math emulation support: we can use
* it from userland as a synthetic FPU, but there is no sane
* way to use it from kernel-based threads (Xenomai or Linux).
*/
if (!fp_kernel_supported())
ptask->flags &= ~RTTST_SWTEST_USE_FPU;
ptask->flags |= RTSWITCH_KERNEL;
err = rtswitch_register_task(ctx, ptask);
if (err)
return err;
snprintf(name, sizeof(name), "rtk%d/%u", ptask->index, ctx->cpu);
task = &ctx->tasks[ptask->index];
arg.ctx = ctx;
arg.task = task;
init_flags = (ptask->flags & RTTST_SWTEST_FPU) ? XNFPU : 0;
/*
* Migrate the calling thread to the same CPU as the created
* task, in order to be sure that the created task is
* suspended when this function returns. This also allow us to
* use the stack to pass the parameters to the created
* task.
*/
set_cpus_allowed(current, cpumask_of_cpu(ctx->cpu));
iattr.tbase = rtdm_tbase;
iattr.name = name;
iattr.flags = init_flags;
iattr.ops = NULL;
iattr.stacksize = 0;
param.rt.prio = 1;
err = xnpod_init_thread(&task->ktask,
&iattr, &xnsched_class_rt, ¶m);
if (!err) {
sattr.mode = 0;
sattr.imask = 0;
sattr.affinity = xnarch_cpumask_of_cpu(ctx->cpu);
sattr.entry = rtswitch_ktask;
sattr.cookie = &arg;
err = xnpod_start_thread(&task->ktask, &sattr);
} else
/*
* In order to avoid calling xnpod_delete_thread with
* invalid thread.
*/
task->base.flags = 0;
/*
* Putting the argument on stack is safe, because the new
* thread will preempt the current thread immediately, and
* will suspend only once the arguments on stack are used.
*/
return err;
}
