/*
|
* Copyright (C) 2008 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* Xenomai is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published
|
* by the Free Software Foundation; either version 2 of the License,
|
* or (at your option) any later version.
|
*
|
* Xenomai is distributed in the hope that it will be useful, but
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with Xenomai; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
* 02111-1307, USA.
|
*/
|
#include <cobalt/kernel/sched.h>
|
|
static void xnsched_rt_init(struct xnsched *sched)
|
{
|
xnsched_initq(&sched->rt.runnable);
|
}
|
|
static void xnsched_rt_requeue(struct xnthread *thread)
|
{
|
/*
|
* Put back at same place: i.e. requeue to head of current
|
* priority group (i.e. LIFO, used for preemption handling).
|
*/
|
__xnsched_rt_requeue(thread);
|
}
|
|
static void xnsched_rt_enqueue(struct xnthread *thread)
|
{
|
/*
|
* Enqueue for next pick: i.e. move to end of current priority
|
* group (i.e. FIFO).
|
*/
|
__xnsched_rt_enqueue(thread);
|
}
|
|
static void xnsched_rt_dequeue(struct xnthread *thread)
|
{
|
/*
|
* Pull from the runnable thread queue.
|
*/
|
__xnsched_rt_dequeue(thread);
|
}
|
|
static void xnsched_rt_rotate(struct xnsched *sched,
|
const union xnsched_policy_param *p)
|
{
|
struct xnthread *thread, *curr;
|
|
if (xnsched_emptyq_p(&sched->rt.runnable))
|
return; /* No runnable thread in this class. */
|
|
curr = sched->curr;
|
|
if (p->rt.prio == XNSCHED_RUNPRIO)
|
thread = curr;
|
else {
|
thread = xnsched_findq(&sched->rt.runnable, p->rt.prio);
|
if (thread == NULL)
|
return;
|
}
|
|
/*
|
* In case we picked the current thread, we have to make sure
|
* not to move it back to the run queue if it was blocked
|
* before we were called. The same goes if the current thread
|
* holds the scheduler lock.
|
*/
|
if (thread != curr ||
|
(!xnthread_test_state(curr, XNTHREAD_BLOCK_BITS) &&
|
curr->lock_count == 0))
|
xnsched_putback(thread);
|
}
|
|
void xnsched_rt_tick(struct xnsched *sched)
|
{
|
/*
|
* The round-robin time credit is only consumed by a running
|
* thread that neither holds the scheduler lock nor was
|
* blocked before entering this callback. As the time slice is
|
* exhausted for the running thread, move it back to the
|
* run queue at the end of its priority group.
|
*/
|
xnsched_putback(sched->curr);
|
}
|
|
static bool xnsched_rt_setparam(struct xnthread *thread,
|
const union xnsched_policy_param *p)
|
{
|
return __xnsched_rt_setparam(thread, p);
|
}
|
|
static void xnsched_rt_getparam(struct xnthread *thread,
|
union xnsched_policy_param *p)
|
{
|
__xnsched_rt_getparam(thread, p);
|
}
|
|
static void xnsched_rt_trackprio(struct xnthread *thread,
|
const union xnsched_policy_param *p)
|
{
|
__xnsched_rt_trackprio(thread, p);
|
}
|
|
static void xnsched_rt_protectprio(struct xnthread *thread, int prio)
|
{
|
__xnsched_rt_protectprio(thread, prio);
|
}
|
|
#ifdef CONFIG_XENO_OPT_VFILE
|
|
struct xnvfile_directory sched_rt_vfroot;
|
|
struct vfile_sched_rt_priv {
|
struct xnthread *curr;
|
};
|
|
struct vfile_sched_rt_data {
|
int cpu;
|
pid_t pid;
|
char name[XNOBJECT_NAME_LEN];
|
xnticks_t period;
|
int cprio;
|
};
|
|
static struct xnvfile_snapshot_ops vfile_sched_rt_ops;
|
|
static struct xnvfile_snapshot vfile_sched_rt = {
|
.privsz = sizeof(struct vfile_sched_rt_priv),
|
.datasz = sizeof(struct vfile_sched_rt_data),
|
.tag = &nkthreadlist_tag,
|
.ops = &vfile_sched_rt_ops,
|
};
|
|
static int vfile_sched_rt_rewind(struct xnvfile_snapshot_iterator *it)
|
{
|
struct vfile_sched_rt_priv *priv = xnvfile_iterator_priv(it);
|
int nrthreads = xnsched_class_rt.nthreads;
|
|
if (nrthreads == 0)
|
return -ESRCH;
|
|
priv->curr = list_first_entry(&nkthreadq, struct xnthread, glink);
|
|
return nrthreads;
|
}
|
|
static int vfile_sched_rt_next(struct xnvfile_snapshot_iterator *it,
|
void *data)
|
{
|
struct vfile_sched_rt_priv *priv = xnvfile_iterator_priv(it);
|
struct vfile_sched_rt_data *p = data;
|
struct xnthread *thread;
|
|
if (priv->curr == NULL)
|
return 0; /* All done. */
|
|
thread = priv->curr;
|
if (list_is_last(&thread->glink, &nkthreadq))
|
priv->curr = NULL;
|
else
|
priv->curr = list_next_entry(thread, glink);
|
|
if (thread->base_class != &xnsched_class_rt ||
|
xnthread_test_state(thread, XNWEAK))
|
return VFILE_SEQ_SKIP;
|
|
p->cpu = xnsched_cpu(thread->sched);
|
p->pid = xnthread_host_pid(thread);
|
memcpy(p->name, thread->name, sizeof(p->name));
|
p->cprio = thread->cprio;
|
p->period = xnthread_get_period(thread);
|
|
return 1;
|
}
|
|
static int vfile_sched_rt_show(struct xnvfile_snapshot_iterator *it,
|
void *data)
|
{
|
struct vfile_sched_rt_data *p = data;
|
char pribuf[16], ptbuf[16];
|
|
if (p == NULL)
|
xnvfile_printf(it, "%-3s %-6s %-8s %-10s %s\n",
|
"CPU", "PID", "PRI", "PERIOD", "NAME");
|
else {
|
ksformat(pribuf, sizeof(pribuf), "%3d", p->cprio);
|
xntimer_format_time(p->period, ptbuf, sizeof(ptbuf));
|
xnvfile_printf(it, "%3u %-6d %-8s %-10s %s\n",
|
p->cpu,
|
p->pid,
|
pribuf,
|
ptbuf,
|
p->name);
|
}
|
|
return 0;
|
}
|
|
static struct xnvfile_snapshot_ops vfile_sched_rt_ops = {
|
.rewind = vfile_sched_rt_rewind,
|
.next = vfile_sched_rt_next,
|
.show = vfile_sched_rt_show,
|
};
|
|
static int xnsched_rt_init_vfile(struct xnsched_class *schedclass,
|
struct xnvfile_directory *vfroot)
|
{
|
int ret;
|
|
ret = xnvfile_init_dir(schedclass->name, &sched_rt_vfroot, vfroot);
|
if (ret)
|
return ret;
|
|
return xnvfile_init_snapshot("threads", &vfile_sched_rt,
|
&sched_rt_vfroot);
|
}
|
|
static void xnsched_rt_cleanup_vfile(struct xnsched_class *schedclass)
|
{
|
xnvfile_destroy_snapshot(&vfile_sched_rt);
|
xnvfile_destroy_dir(&sched_rt_vfroot);
|
}
|
|
#endif /* CONFIG_XENO_OPT_VFILE */
|
|
struct xnsched_class xnsched_class_rt = {
|
.sched_init = xnsched_rt_init,
|
.sched_enqueue = xnsched_rt_enqueue,
|
.sched_dequeue = xnsched_rt_dequeue,
|
.sched_requeue = xnsched_rt_requeue,
|
.sched_pick = xnsched_rt_pick,
|
.sched_tick = xnsched_rt_tick,
|
.sched_rotate = xnsched_rt_rotate,
|
.sched_forget = NULL,
|
.sched_kick = NULL,
|
.sched_declare = NULL,
|
.sched_setparam = xnsched_rt_setparam,
|
.sched_trackprio = xnsched_rt_trackprio,
|
.sched_protectprio = xnsched_rt_protectprio,
|
.sched_getparam = xnsched_rt_getparam,
|
#ifdef CONFIG_XENO_OPT_VFILE
|
.sched_init_vfile = xnsched_rt_init_vfile,
|
.sched_cleanup_vfile = xnsched_rt_cleanup_vfile,
|
#endif
|
.weight = XNSCHED_CLASS_WEIGHT(4),
|
.policy = SCHED_FIFO,
|
.name = "rt"
|
};
|
EXPORT_SYMBOL_GPL(xnsched_class_rt);
|
