/*
|
* Copyright (C) 2013 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>
|
#include <cobalt/uapi/sched.h>
|
|
static void xnsched_weak_init(struct xnsched *sched)
|
{
|
xnsched_initq(&sched->weak.runnable);
|
}
|
|
static void xnsched_weak_requeue(struct xnthread *thread)
|
{
|
xnsched_addq(&thread->sched->weak.runnable, thread);
|
}
|
|
static void xnsched_weak_enqueue(struct xnthread *thread)
|
{
|
xnsched_addq_tail(&thread->sched->weak.runnable, thread);
|
}
|
|
static void xnsched_weak_dequeue(struct xnthread *thread)
|
{
|
xnsched_delq(&thread->sched->weak.runnable, thread);
|
}
|
|
static struct xnthread *xnsched_weak_pick(struct xnsched *sched)
|
{
|
return xnsched_getq(&sched->weak.runnable);
|
}
|
|
static bool xnsched_weak_setparam(struct xnthread *thread,
|
const union xnsched_policy_param *p)
|
{
|
if (!xnthread_test_state(thread, XNBOOST))
|
xnthread_set_state(thread, XNWEAK);
|
|
return xnsched_set_effective_priority(thread, p->weak.prio);
|
}
|
|
static void xnsched_weak_getparam(struct xnthread *thread,
|
union xnsched_policy_param *p)
|
{
|
p->weak.prio = thread->cprio;
|
}
|
|
static void xnsched_weak_trackprio(struct xnthread *thread,
|
const union xnsched_policy_param *p)
|
{
|
if (p)
|
thread->cprio = p->weak.prio;
|
else
|
thread->cprio = thread->bprio;
|
}
|
|
static void xnsched_weak_protectprio(struct xnthread *thread, int prio)
|
{
|
if (prio > XNSCHED_WEAK_MAX_PRIO)
|
prio = XNSCHED_WEAK_MAX_PRIO;
|
|
thread->cprio = prio;
|
}
|
|
static int xnsched_weak_chkparam(struct xnthread *thread,
|
const union xnsched_policy_param *p)
|
{
|
if (p->weak.prio < XNSCHED_WEAK_MIN_PRIO ||
|
p->weak.prio > XNSCHED_WEAK_MAX_PRIO)
|
return -EINVAL;
|
|
return 0;
|
}
|
|
#ifdef CONFIG_XENO_OPT_VFILE
|
|
struct xnvfile_directory sched_weak_vfroot;
|
|
struct vfile_sched_weak_priv {
|
struct xnthread *curr;
|
};
|
|
struct vfile_sched_weak_data {
|
int cpu;
|
pid_t pid;
|
char name[XNOBJECT_NAME_LEN];
|
int cprio;
|
};
|
|
static struct xnvfile_snapshot_ops vfile_sched_weak_ops;
|
|
static struct xnvfile_snapshot vfile_sched_weak = {
|
.privsz = sizeof(struct vfile_sched_weak_priv),
|
.datasz = sizeof(struct vfile_sched_weak_data),
|
.tag = &nkthreadlist_tag,
|
.ops = &vfile_sched_weak_ops,
|
};
|
|
static int vfile_sched_weak_rewind(struct xnvfile_snapshot_iterator *it)
|
{
|
struct vfile_sched_weak_priv *priv = xnvfile_iterator_priv(it);
|
int nrthreads = xnsched_class_weak.nthreads;
|
|
if (nrthreads == 0)
|
return -ESRCH;
|
|
priv->curr = list_first_entry(&nkthreadq, struct xnthread, glink);
|
|
return nrthreads;
|
}
|
|
static int vfile_sched_weak_next(struct xnvfile_snapshot_iterator *it,
|
void *data)
|
{
|
struct vfile_sched_weak_priv *priv = xnvfile_iterator_priv(it);
|
struct vfile_sched_weak_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_weak)
|
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;
|
|
return 1;
|
}
|
|
static int vfile_sched_weak_show(struct xnvfile_snapshot_iterator *it,
|
void *data)
|
{
|
struct vfile_sched_weak_data *p = data;
|
char pribuf[16];
|
|
if (p == NULL)
|
xnvfile_printf(it, "%-3s %-6s %-4s %s\n",
|
"CPU", "PID", "PRI", "NAME");
|
else {
|
ksformat(pribuf, sizeof(pribuf), "%3d", p->cprio);
|
xnvfile_printf(it, "%3u %-6d %-4s %s\n",
|
p->cpu,
|
p->pid,
|
pribuf,
|
p->name);
|
}
|
|
return 0;
|
}
|
|
static struct xnvfile_snapshot_ops vfile_sched_weak_ops = {
|
.rewind = vfile_sched_weak_rewind,
|
.next = vfile_sched_weak_next,
|
.show = vfile_sched_weak_show,
|
};
|
|
static int xnsched_weak_init_vfile(struct xnsched_class *schedclass,
|
struct xnvfile_directory *vfroot)
|
{
|
int ret;
|
|
ret = xnvfile_init_dir(schedclass->name, &sched_weak_vfroot, vfroot);
|
if (ret)
|
return ret;
|
|
return xnvfile_init_snapshot("threads", &vfile_sched_weak,
|
&sched_weak_vfroot);
|
}
|
|
static void xnsched_weak_cleanup_vfile(struct xnsched_class *schedclass)
|
{
|
xnvfile_destroy_snapshot(&vfile_sched_weak);
|
xnvfile_destroy_dir(&sched_weak_vfroot);
|
}
|
|
#endif /* CONFIG_XENO_OPT_VFILE */
|
|
struct xnsched_class xnsched_class_weak = {
|
.sched_init = xnsched_weak_init,
|
.sched_enqueue = xnsched_weak_enqueue,
|
.sched_dequeue = xnsched_weak_dequeue,
|
.sched_requeue = xnsched_weak_requeue,
|
.sched_pick = xnsched_weak_pick,
|
.sched_tick = NULL,
|
.sched_rotate = NULL,
|
.sched_forget = NULL,
|
.sched_kick = NULL,
|
.sched_chkparam = xnsched_weak_chkparam,
|
.sched_setparam = xnsched_weak_setparam,
|
.sched_trackprio = xnsched_weak_trackprio,
|
.sched_protectprio = xnsched_weak_protectprio,
|
.sched_getparam = xnsched_weak_getparam,
|
#ifdef CONFIG_XENO_OPT_VFILE
|
.sched_init_vfile = xnsched_weak_init_vfile,
|
.sched_cleanup_vfile = xnsched_weak_cleanup_vfile,
|
#endif
|
.weight = XNSCHED_CLASS_WEIGHT(1),
|
.policy = SCHED_WEAK,
|
.name = "weak"
|
};
|
EXPORT_SYMBOL_GPL(xnsched_class_weak);
|
