/*
|
* SPDX-License-Identifier: GPL-2.0
|
*
|
* Copyright (C) 2001-2020 Philippe Gerum <rpm@xenomai.org>.
|
*/
|
|
#include <cobalt/kernel/thread.h>
|
#include <cobalt/kernel/sched.h>
|
#include <cobalt/kernel/assert.h>
|
#include <pipeline/sched.h>
|
#include <trace/events/cobalt-core.h>
|
|
int pipeline_schedule(struct xnsched *sched)
|
{
|
int ret = 0;
|
|
XENO_WARN_ON_ONCE(COBALT,
|
!hard_irqs_disabled() && is_secondary_domain());
|
|
if (!xnarch_escalate())
|
ret = ___xnsched_run(sched);
|
|
return ret;
|
}
|
EXPORT_SYMBOL_GPL(pipeline_schedule);
|
|
void pipeline_prep_switch_oob(struct xnthread *root)
|
{
|
struct xnarchtcb *rootcb = xnthread_archtcb(root);
|
struct task_struct *p = current;
|
|
ipipe_notify_root_preemption();
|
/* Remember the preempted Linux task pointer. */
|
rootcb->core.host_task = p;
|
rootcb->core.tsp = &p->thread;
|
rootcb->core.mm = rootcb->core.active_mm = ipipe_get_active_mm();
|
rootcb->core.tip = task_thread_info(p);
|
xnarch_leave_root(root);
|
}
|
|
#ifdef CONFIG_XENO_ARCH_FPU
|
|
static void switch_fpu(void)
|
{
|
struct xnsched *sched = xnsched_current();
|
struct xnthread *curr = sched->curr;
|
|
if (!xnthread_test_state(curr, XNFPU))
|
return;
|
|
xnarch_switch_fpu(sched->fpuholder, curr);
|
sched->fpuholder = curr;
|
}
|
|
static void giveup_fpu(struct xnthread *thread)
|
{
|
struct xnsched *sched = thread->sched;
|
|
if (thread == sched->fpuholder)
|
sched->fpuholder = NULL;
|
}
|
|
#else
|
|
static inline void giveup_fpu(struct xnthread *thread)
|
{ }
|
|
#endif /* !CONFIG_XENO_ARCH_FPU */
|
|
bool pipeline_switch_to(struct xnthread *prev, struct xnthread *next,
|
bool leaving_inband)
|
{
|
xnarch_switch_to(prev, next);
|
|
/*
|
* Test whether we transitioned from primary mode to secondary
|
* over a shadow thread, caused by a call to xnthread_relax().
|
* In such a case, we are running over the regular schedule()
|
* tail code, so we have to tell the caller to skip the Cobalt
|
* tail code.
|
*/
|
if (!leaving_inband && is_secondary_domain()) {
|
__ipipe_complete_domain_migration();
|
XENO_BUG_ON(COBALT, xnthread_current() == NULL);
|
/*
|
* Interrupts must be disabled here (has to be done on
|
* entry of the Linux [__]switch_to function), but it
|
* is what callers expect, specifically the reschedule
|
* of an IRQ handler that hit before we call
|
* xnsched_run in xnthread_suspend() when relaxing a
|
* thread.
|
*/
|
XENO_BUG_ON(COBALT, !hard_irqs_disabled());
|
return true;
|
}
|
|
switch_fpu();
|
|
return false;
|
}
|
|
void pipeline_init_shadow_tcb(struct xnthread *thread)
|
{
|
struct xnarchtcb *tcb = xnthread_archtcb(thread);
|
struct task_struct *p = current;
|
|
/*
|
* If the current task is a kthread, the pipeline will take
|
* the necessary steps to make the FPU usable in such
|
* context. The kernel already took care of this issue for
|
* userland tasks (e.g. setting up a clean backup area).
|
*/
|
__ipipe_share_current(0);
|
|
tcb->core.host_task = p;
|
tcb->core.tsp = &p->thread;
|
tcb->core.mm = p->mm;
|
tcb->core.active_mm = p->mm;
|
tcb->core.tip = task_thread_info(p);
|
#ifdef CONFIG_XENO_ARCH_FPU
|
tcb->core.user_fpu_owner = p;
|
#endif /* CONFIG_XENO_ARCH_FPU */
|
xnarch_init_shadow_tcb(thread);
|
|
trace_cobalt_shadow_map(thread);
|
}
|
|
void pipeline_init_root_tcb(struct xnthread *thread)
|
{
|
struct xnarchtcb *tcb = xnthread_archtcb(thread);
|
struct task_struct *p = current;
|
|
tcb->core.host_task = p;
|
tcb->core.tsp = &tcb->core.ts;
|
tcb->core.mm = p->mm;
|
tcb->core.tip = NULL;
|
xnarch_init_root_tcb(thread);
|
}
|
|
int pipeline_leave_inband(void)
|
{
|
int ret;
|
|
ret = __ipipe_migrate_head();
|
if (ret)
|
return ret;
|
|
switch_fpu();
|
|
return 0;
|
}
|
|
int pipeline_leave_oob_prepare(void)
|
{
|
struct xnthread *curr = xnthread_current();
|
struct task_struct *p = current;
|
int suspmask = XNRELAX;
|
|
set_current_state(p->state & ~TASK_NOWAKEUP);
|
|
/*
|
* If current is being debugged, record that it should migrate
|
* back in case it resumes in userspace. If it resumes in
|
* kernel space, i.e. over a restarting syscall, the
|
* associated hardening will both clear XNCONTHI and disable
|
* the user return notifier again.
|
*/
|
if (xnthread_test_state(curr, XNSSTEP)) {
|
xnthread_set_info(curr, XNCONTHI);
|
ipipe_enable_user_intret_notifier();
|
suspmask |= XNDBGSTOP;
|
}
|
/*
|
* Return the suspension bits the caller should pass to
|
* xnthread_suspend().
|
*/
|
return suspmask;
|
}
|
|
void pipeline_leave_oob_finish(void)
|
{
|
__ipipe_reenter_root();
|
}
|
|
void pipeline_finalize_thread(struct xnthread *thread)
|
{
|
giveup_fpu(thread);
|
}
|
|
void pipeline_raise_mayday(struct task_struct *tsk)
|
{
|
ipipe_raise_mayday(tsk);
|
}
|
|
void pipeline_clear_mayday(void) /* May solely affect current. */
|
{
|
ipipe_clear_thread_flag(TIP_MAYDAY);
|
}
|
