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_create(const char *name,
u_long prio,
u_long sstack, u_long ustack, u_long flags, u_long *tid_r)
{
union xnsched_policy_param param;
struct xnthread_init_attr attr;
xnflags_t bflags = 0;
psostask_t *task;
u_long err;
spl_t s;
int n;
/* Xenomai extension: we accept priority level #0 for creating
non-RT tasks (i.e. underlaid by SCHED_NORMAL pthreads),
which are allowed to call into the pSOS emulator, usually
for synchronization services. */
if (prio > 255)
return ERR_PRIOR;
task = (psostask_t *)xnmalloc(sizeof(*task));
if (!task)
return ERR_NOTCB;
if (flags & T_FPU)
bflags |= XNFPU;
#ifdef CONFIG_XENO_OPT_PERVASIVE
if (flags & T_SHADOW)
bflags |= XNSHADOW;
#endif /* CONFIG_XENO_OPT_PERVASIVE */
ustack += sstack;
if (!(flags & T_SHADOW) && ustack < 1024) {
xnfree(task);
return ERR_TINYSTK;
}
if (name && *name)
xnobject_copy_name(task->name, name);
else
/* i.e. Anonymous object which must be accessible from
user-space. */
sprintf(task->name, "anon_task%lu", psos_task_ids++);
attr.tbase = psos_tbase;
attr.name = task->name;
attr.flags = bflags;
attr.ops = &psos_task_ops;
attr.stacksize = ustack;
param.rt.prio = prio;
if (xnpod_init_thread(&task->threadbase,
&attr, &xnsched_class_rt, ¶m) != 0) {
xnfree(task);
return ERR_NOSTK; /* Assume this is the only possible failure */
}
xnthread_time_slice(&task->threadbase) = psos_time_slice;
taskev_init(&task->evgroup);
inith(&task->link);
for (n = 0; n < PSOSTASK_NOTEPAD_REGS; n++)
task->notepad[n] = 0;
initgq(&task->alarmq,
&xnmod_glink_queue,
xnmod_alloc_glinks,
XNMOD_GHOLDER_THRESHOLD);
task->magic = PSOS_TASK_MAGIC;
xnlock_get_irqsave(&nklock, s);
appendq(&psostaskq, &task->link);
*tid_r = (u_long)task;
xnlock_put_irqrestore(&nklock, s);
err = xnthread_register(&task->threadbase, task->name);
if (err) {
t_delete((u_long)task);
return err;
}
xnarch_create_display(&task->threadbase, task->name, psostask);
return SUCCESS;
}
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;
}
