This is a patch to the Xen Hypervisor that adds a scheduler
that provides partial ARINC653 CPU scheduling.
Anthony Boorsma
www.DornerWorks.com
*** Diffing -rupN
diff -rupN a/tools/libxc/xc_core.c b/tools/libxc/xc_core.c
--- a/tools/libxc/xc_core.c 2009-08-06
09:57:25.000000000 -0400
+++ b/tools/libxc/xc_core.c 2010-03-19
09:07:29.595745100 -0400
@@ -321,7 +321,15 @@ elfnote_dump_none(void *args,
dumpcore_r
struct xen_dumpcore_elfnote_none_desc
none;
elfnote_init(&elfnote);
- memset(&none, 0, sizeof(none));
+ /*
+ * josh holtrop
<DornerWorks.com> - 2009-01-04 - avoid compilation problem
+ * with warning "memset used
with constant zero length parameter" and
+ * warnings treated as errors with
the new gcc in Ubuntu 9.10
+ */
+ if (sizeof(none) > 0)
+ {
+
memset(&none, 0, sizeof(none));
+ }
elfnote.descsz = sizeof(none);
elfnote.type =
XEN_ELFNOTE_DUMPCORE_NONE;
diff -rupN a/tools/libxc/xc_misc.c b/tools/libxc/xc_misc.c
--- a/tools/libxc/xc_misc.c 2009-08-06
09:57:25.000000000 -0400
+++ b/tools/libxc/xc_misc.c 2010-03-19
09:09:45.906278500 -0400
@@ -2,6 +2,8 @@
* xc_misc.c
*
* Miscellaneous control interface functions.
+ *
+ * xc_sched_op function added by DornerWorks
<DornerWorks.com>.
*/
#include "xc_private.h"
@@ -358,6 +360,60 @@ void *xc_map_foreign_pages(int
xc_handle
return res;
}
+int xc_sched_op(int xc_handle, int sched_op, void * arg)
+{
+ DECLARE_HYPERCALL;
+ int rc;
+ int argsize = 0;
+
+ hypercall.op =
__HYPERVISOR_sched_op;
+ hypercall.arg[0] = sched_op;
+ hypercall.arg[1] = (unsigned long) arg;
+
+ switch (sched_op)
+ {
+ case SCHEDOP_yield:
+ argsize = 0;
+ break;
+ case SCHEDOP_block:
+ argsize = 0;
+ break;
+ case SCHEDOP_shutdown:
+ argsize =
sizeof(sched_shutdown_t);
+ break;
+ case SCHEDOP_poll:
+ argsize =
sizeof(sched_poll_t);
+ break;
+ case SCHEDOP_remote_shutdown:
+ argsize =
sizeof(sched_remote_shutdown_t);
+ break;
+ case SCHEDOP_arinc653_sched_set:
+ argsize =
sizeof(sched_arinc653_sched_set_t);
+ break;
+ default:
+
PERROR("xc_sched_op(): Unknown scheduler operation.");
+ break;
+ }
+
+ if (argsize > 0)
+ {
+ if ( (rc =
lock_pages(arg, argsize)) != 0 )
+ {
+
PERROR("Could not lock memory");
+
return rc;
+ }
+ }
+
+ rc = do_xen_hypercall(xc_handle,
&hypercall);
+
+ if (argsize > 0)
+ {
+
unlock_pages(arg, argsize);
+ }
+
+ return rc;
+}
+
/*
* Local variables:
* mode: C
diff -rupN a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h
--- a/tools/libxc/xenctrl.h 2009-08-06
09:57:25.000000000 -0400
+++ b/tools/libxc/xenctrl.h 2010-03-19
09:16:32.104190500 -0400
@@ -7,6 +7,9 @@
*
* xc_gnttab functions:
* Copyright (c) 2007-2008, D G Murray <Derek.Murray@xxxxxxxxxxxx>
+ *
+ * xc_sched_op function:
+ * Copyright (c) 2010, DornerWorks, Ltd.
<DornerWorks.com>
*/
#ifndef XENCTRL_H
@@ -1267,4 +1270,7 @@ int xc_get_vcpu_migration_delay(int
xc_h
int xc_get_cpuidle_max_cstate(int xc_handle, uint32_t
*value);
int xc_set_cpuidle_max_cstate(int xc_handle, uint32_t
value);
+/* perform a scheduler operation */
+int xc_sched_op(int xc_handle, int sched_op, void * arg);
+
#endif /* XENCTRL_H */
diff -rupN a/xen/common/Makefile b/xen/common/Makefile
--- a/xen/common/Makefile 2009-08-06
09:57:27.000000000 -0400
+++ b/xen/common/Makefile 2010-03-18
19:34:05.200130400 -0400
@@ -13,6 +13,7 @@ obj-y += page_alloc.o
obj-y += rangeset.o
obj-y += sched_credit.o
obj-y += sched_sedf.o
+obj-y += sched_arinc653.o
obj-y += schedule.o
obj-y += shutdown.o
obj-y += softirq.o
diff -rupN a/xen/common/sched_arinc653.c
b/xen/common/sched_arinc653.c
--- a/xen/common/sched_arinc653.c 1969-12-31
19:00:00.000000000 -0500
+++ b/xen/common/sched_arinc653.c 2010-03-19
09:12:32.105381300 -0400
@@ -0,0 +1,725 @@
+/*
+ * File: sched_arinc653.c
+ * Copyright (c) 2009, DornerWorks, Ltd.
<DornerWorks.com>
+ *
+ * Description:
+ * This file provides an ARINC653-compatible
scheduling algorithm
+ * for use in Xen.
+ *
+ * This program 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.
+ *
+ * This program 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.
+ */
+
+
+/**************************************************************************
+ *
Includes
*
+
*************************************************************************/
+#include <xen/lib.h>
+#include <xen/sched.h>
+#include <xen/sched-if.h>
+#include <xen/timer.h>
+#include <xen/softirq.h>
+#include <xen/time.h>
+#include <xen/errno.h>
+#include <xen/sched_arinc653.h>
+#include <xen/list.h>
+#include
<public/sched.h>
/* ARINC653_MAX_DOMAINS_PER_SCHEDULE */
+
+
+/**************************************************************************
+ * Private
Macros
*
+
*************************************************************************/
+
+/* Retrieve the idle VCPU for a given physical CPU */
+#define IDLETASK(cpu) ((struct vcpu *)
per_cpu(schedule_data, (cpu)).idle)
+
+/*
+ * Return a pointer to the ARINC653-specific scheduler data
information
+ * associated with the given VCPU (vc)
+ */
+#define AVCPU(vc) ((arinc653_vcpu_t *)(vc)->sched_priv)
+
+/**************************************************************************
+ * Private Type
Definitions
*
+ *************************************************************************/
+/*
+ * The sched_entry_t structure holds a single entry of the
+ * ARINC653 schedule.
+ */
+typedef struct sched_entry_s
+{
+ /* dom_handle holds the handle
("UUID") for the domain that this
+ * schedule entry refers to. */
+ xen_domain_handle_t dom_handle;
+ /* vcpu_id holds the VCPU number for the
VCPU that this schedule
+ * entry refers to. */
+
int
vcpu_id;
+ /* runtime holds the number of
nanoseconds that the VCPU for this
+ * schedule entry should be allowed
to run per major frame. */
+
s_time_t
runtime;
+} sched_entry_t;
+
+/*
+ * The arinc653_vcpu_t structure holds
ARINC653-scheduler-specific
+ * information for all non-idle VCPUs
+ */
+typedef struct arinc653_vcpu_s
+{
+ /* runtime stores the number of
nanoseconds that this VCPU is allowed
+ * to run per major frame. */
+
s_time_t
runtime;
+ /* time_left stores the number of
nanoseconds (its "credit") that this
+ * VCPU still has left in the
current major frame. */
+
s_time_t
time_left;
+ /* last_activation_time stores the time
that this VCPU was switched
+ * to for credit-accounting
purposes. */
+
s_time_t
last_activation_time;
+ /* list holds the linked list
information for whichever list this
+ * VCPU is stored on. */
+ struct list_head list;
+ /* vc points to Xen's struct vcpu so we
can get to it from an
+ * arinc653_vcpu_t pointer. */
+ struct vcpu
* vc;
+ /* The active flag tells whether this
VCPU is active in the current
+ * ARINC653 schedule or not. */
+
bool_t
active;
+} arinc653_vcpu_t;
+
+
+/**************************************************************************
+ * Global
Data
*
+
*************************************************************************/
+
+/*
+ * This array holds the active ARINC653 schedule.
+ * When the system tries to start a new VCPU, this schedule
is scanned
+ * to look for a matching (handle, VCPU #) pair. If both
the handle ("UUID")
+ * and VCPU number match, then the VCPU is allowed to run.
Its run time
+ * (per major frame) is given in the third entry of the
schedule.
+ */
+static sched_entry_t
arinc653_schedule[ARINC653_MAX_DOMAINS_PER_SCHEDULE] = {
+ { "", 0, MILLISECS(10) }
+};
+
+/*
+ * This variable holds the number of entries that are valid
in
+ * the arinc653_schedule table.
+ * This is not necessarily the same as the number of
domains in the
+ * schedule, since a domain with multiple VCPUs could have
a different
+ * schedule entry for each VCPU.
+ */
+static int num_schedule_entries = 1;
+
+/*
+ * arinc653_major_frame holds the major frame time for the
ARINC653 schedule.
+ */
+static s_time_t arinc653_major_frame = MILLISECS(10);
+
+/*
+ * next_major_frame holds the time that the next major
frame starts
+ */
+static s_time_t next_major_frame = 0;
+
+/* Linked list to store runnable domains in the current
schedule with
+ * time left this major frame */
+static LIST_HEAD(run_list);
+
+/* Linked list to store blocked domains in the current
schedule */
+static LIST_HEAD(blocked_list);
+
+/* Linked list to store runnable domains in the current
schedule
+ * that have no time left in this major frame */
+static LIST_HEAD(expired_list);
+
+/* Linked list to store runnable domains not in the current
schedule */
+static LIST_HEAD(deactivated_run_list);
+
+/* Linked list to store blocked domains not in the current
schedule */
+static LIST_HEAD(deactivated_blocked_list);
+
+
+/**************************************************************************
+ * Scheduler
functions
*
+
*************************************************************************/
+
+static int dom_handle_cmp(const xen_domain_handle_t h1,
+ const
xen_domain_handle_t h2)
+{
+ return memcmp(h1, h2,
sizeof(xen_domain_handle_t));
+}
+
+/*
+ * This function scans the current ARINC653 schedule and
looks
+ * for an entry that matches the VCPU v.
+ * If an entry is found, a pointer to it is returned.
+ * Otherwise, NULL is returned.
+ */
+static sched_entry_t * find_sched_entry(struct vcpu * v)
+{
+ sched_entry_t * sched_entry = NULL;
+ if (v != NULL)
+ {
+ for (int i = 0;
i < num_schedule_entries; i++)
+ {
+
if ( (v->vcpu_id == arinc653_schedule[i].vcpu_id)
+
&& (dom_handle_cmp(arinc653_schedule[i].dom_handle,
+
v->domain->handle) == 0))
+
{
+
sched_entry = &arinc653_schedule[i];
+
break;
+
}
+ }
+ }
+ return sched_entry;
+}
+
+/*
+ * This function is called by the hypervisor when a
privileged domain
+ * invokes the HYPERVISOR_sched_op hypercall with a command
of
+ * SCHEDOP_arinc653_sched_set.
+ * It returns 0 on success and nonzero upon error.
+ * This function is only called from do_sched_op(), defined
within
+ * xen/common/schedule.c. The parameter schedule is set to
be the
+ * address of a local variable from within do_sched_op(),
so it is
+ * guaranteed not to be NULL.
+ */
+int arinc653_sched_set(sched_arinc653_sched_set_t *
schedule)
+{
+ int ret = 0;
+ s_time_t total_runtime = 0;
+ int found_dom0 = 0;
+ const static xen_domain_handle_t
dom0_handle = {0};
+
+ /* check for valid major frame and
number of schedule entries */
+ if ( (schedule->major_frame <= 0)
+ ||
(schedule->num_sched_entries < 1)
+ ||
(schedule->num_sched_entries > ARINC653_MAX_DOMAINS_PER_SCHEDULE) )
+ {
+ ret = -EINVAL;
+ }
+ if (ret == 0)
+ {
+ for (int i = 0;
i < schedule->num_sched_entries; i++)
+ {
+
/*
+
* look for domain 0 handle - every schedule must contain
+
* some time for domain 0 to run
+
*/
+
if (dom_handle_cmp(schedule->sched_entries[i].dom_handle,
+ dom0_handle)
== 0)
+
{
+
found_dom0 = 1;
+
}
+
/* check for a valid VCPU id and runtime */
+
if ( (schedule->sched_entries[i].vcpu_id < 0)
+
|| (schedule->sched_entries[i].runtime <= 0) )
+
{
+
ret = -EINVAL;
+
}
+
else
+
{
+
total_runtime += schedule->sched_entries[i].runtime;
+
}
+ }
+ }
+ if (ret == 0)
+ {
+ /* error if the
schedule doesn't contain a slot for domain 0 */
+ if (found_dom0
== 0)
+ {
+
ret = -EINVAL;
+ }
+ }
+ if (ret == 0)
+ {
+ /* error if the
major frame is not large enough to run all entries */
+ if
(total_runtime > schedule->major_frame)
+ {
+
ret = -EINVAL;
+ }
+ }
+ if (ret == 0)
+ {
+ arinc653_vcpu_t
* avcpu;
+ arinc653_vcpu_t
* avcpu_tmp;
+
+ /* copy the new
schedule into place */
+
num_schedule_entries = schedule->num_sched_entries;
+
arinc653_major_frame = schedule->major_frame;
+ for (int i = 0;
i < schedule->num_sched_entries; i++)
+ {
+
memcpy(arinc653_schedule[i].dom_handle,
+
schedule->sched_entries[i].dom_handle,
+
sizeof(arinc653_schedule[i].dom_handle));
+
arinc653_schedule[i].vcpu_id = schedule->sched_entries[i].vcpu_id;
+
arinc653_schedule[i].runtime = schedule->sched_entries[i].runtime;
+ }
+
+ /*
+ * The
newly installed schedule takes effect immediately.
+ * We do
not even wait for the current major frame to expire.
+ * So, we
need to update all of our VCPU lists to reflect the
+ * new
schedule here.
+ */
+
+ /*
+ * There
should be nothing in the expired_list when we start the
+ * next
major frame for the new schedule, so move everything
+ *
currently there into the run_list.
+ */
+
list_splice_init(&expired_list, &run_list);
+
+ /*
+ * Process
entries on the run_list (this will now include
+ * entries
that just came from the expired list).
+ * If the
VCPU is in the current schedule, update its
+ * runtime
and mark it active.
+ * The
time_left parameter will be updated upon the next
+ *
invocation of the do_schedule callback function because a
+ * new
major frame will start.
+ * It is
just set to zero here "defensively."
+ * If the
VCPU is not in the new schedule, mark it inactive
+ * and move
it to the deactivated_run_list.
+ */
+
list_for_each_entry_safe(avcpu, avcpu_tmp, &run_list, list)
+ {
+
sched_entry_t * sched_entry = find_sched_entry(avcpu->vc);
+
if (sched_entry != NULL)
+
{
+
avcpu->active = 1;
+
avcpu->runtime = sched_entry->runtime;
+
avcpu->time_left = 0;
+
}
+
else
+
{
+
avcpu->active = 0;
+
list_move(&avcpu->list, &deactivated_run_list);
+
}
+ }
+
+ /*
+ * Process
entries on the blocked_list.
+ * If the
VCPU is in the current schedule, update its
+ * runtime
and mark it active.
+ * The
time_left parameter will be updated upon the next
+ *
invocation of the do_schedule callback function because a
+ * new
major frame will start.
+ * It is
just set to zero here "defensively."
+ * If the
VCPU is not in the new schedule, mark it inactive
+ * and move
it to the deactivated_blocked_list.
+ */
+
list_for_each_entry_safe(avcpu, avcpu_tmp, &blocked_list, list)
+ {
+
sched_entry_t * sched_entry = find_sched_entry(avcpu->vc);
+
if (sched_entry != NULL)
+
{
+
avcpu->active = 1;
+ avcpu->runtime
= sched_entry->runtime;
+
avcpu->time_left = 0;
+
}
+
else
+
{
+
avcpu->active = 0;
+
list_move(&avcpu->list, &deactivated_blocked_list);
+
}
+ }
+
+ /*
+ * Process
entries on the deactivated_run_list.
+ * If the
VCPU is now in the current schedule, update its
+ * runtime,
mark it active, and move it to the run_list.
+ * The
time_left parameter will be updated upon the next
+ *
invocation of the do_schedule callback function because a
+ * new
major frame will start.
+ * It is
just set to zero here "defensively."
+ * If the
VCPU is not in the new schedule, do nothing because
+ * it is
already in the correct place.
+ */
+
list_for_each_entry_safe(avcpu, avcpu_tmp, &deactivated_run_list, list)
+ {
+
sched_entry_t * sched_entry = find_sched_entry(avcpu->vc);
+
if (sched_entry != NULL)
+
{
+
avcpu->active = 1;
+
avcpu->runtime = sched_entry->runtime;
+
avcpu->time_left = 0;
+
list_move(&avcpu->list, &run_list);
+
}
+ }
+
+ /*
+ * Process
entries on the deactivated_blocked_list.
+ * If the
VCPU is now in the current schedule, update its
+ * runtime,
mark it active, and move it to the blocked_list.
+ * The
time_left parameter will be updated upon the next
+ *
invocation of the do_schedule callback function because a
+ * new
major frame will start.
+ * It is
just set to zero here "defensively."
+ * If the
VCPU is not in the new schedule, do nothing because
+ * it is
already in the correct place.
+ */
+
list_for_each_entry_safe(avcpu, avcpu_tmp,
+
&deactivated_blocked_list, list)
+ {
+
sched_entry_t * sched_entry = find_sched_entry(avcpu->vc);
+
if (sched_entry != NULL)
+
{
+
avcpu->active = 1;
+
avcpu->runtime = sched_entry->runtime;
+
avcpu->time_left = 0;
+
list_move(&avcpu->list, &blocked_list);
+
}
+ }
+
+ /*
+ * Signal a
new major frame to begin. The next major frame
+ * is set
up by the do_schedule callback function when it
+ * is next
invoked.
+ */
+ next_major_frame
= NOW();
+ }
+ return ret;
+}
+
+/*
+ * Xen scheduler callback function to initialize a virtual
CPU (VCPU)
+ *
+ * This function should return 0 if the VCPU is allowed to
run and
+ * nonzero if there is an error.
+ */
+static int arinc653_init_vcpu(struct vcpu * v)
+{
+ int ret = -1;
+
+ if (is_idle_vcpu(v))
+ {
+ /*
+ * The idle
VCPU is created by Xen to run when no domains
+ * are
runnable or require CPU time.
+ * It is
similar to an "idle task" or "halt loop" process
+ * in an
operating system.
+ * We do
not track any scheduler information for the idle VCPU.
+ */
+ v->sched_priv
= NULL;
+ ret = 0;
+ }
+ else
+ {
+ v->sched_priv
= xmalloc(arinc653_vcpu_t);
+ if (AVCPU(v) !=
NULL)
+ {
+ /*
+
* Initialize our ARINC653 scheduler-specific information
+
* for the VCPU.
+
* The VCPU starts out on the blocked list.
+
* When Xen is ready for the VCPU to run, it will call
+
* the vcpu_wake scheduler callback function and our
+
* scheduler will move the VCPU to the run_list.
+
*/
+
sched_entry_t * sched_entry = find_sched_entry(v);
+
AVCPU(v)->vc = v;
+
AVCPU(v)->last_activation_time = 0;
+
if (sched_entry != NULL)
+
{
+
/* the new VCPU is in the current schedule */
+
AVCPU(v)->active = 1;
+
AVCPU(v)->runtime = sched_entry->runtime;
+
AVCPU(v)->time_left = sched_entry->runtime;
+
list_add(&AVCPU(v)->list, &blocked_list);
+
}
+
else
+
{
+
/* the new VCPU is NOT in the current schedule */
+
AVCPU(v)->active = 0;
+
AVCPU(v)->runtime = 0;
+
AVCPU(v)->time_left = 0;
+
list_add(&AVCPU(v)->list, &deactivated_blocked_list);
+
}
+
ret = 0;
+ }
+ }
+
+ return ret;
+}
+
+/*
+ * Xen scheduler callback function to remove a VCPU
+ */
+static void arinc653_destroy_vcpu(struct vcpu * v)
+{
+ if (AVCPU(v) != NULL)
+ {
+ /* remove the
VCPU from whichever list it is on */
+
list_del(&AVCPU(v)->list);
+ /* free the arinc653_vcpu
structure */
+ xfree(AVCPU(v));
+ }
+}
+
+/*
+ * This function searches the run list to find the next
VCPU
+ * to run.
+ * If a VCPU other than domain 0 is runnable, it will be
returned.
+ * Otherwise, if domain 0 is runnable, it will be returned.
+ * Otherwise, the idle task will be returned.
+ */
+static struct vcpu * find_next_runnable_vcpu(void)
+{
+ arinc653_vcpu_t *
avcpu;
/* loop index variable */
+ struct vcpu * dom0_task = NULL;
+ struct vcpu * new_task = NULL;
+ int cpu = smp_processor_id();
+
+ BUG_ON(cpu !=
0); /* this
implementation only supports one CPU */
+
+ /* select a new task from the run_list
to run, choosing any runnable
+ * task other than domain 0 first
*/
+ list_for_each_entry(avcpu,
&run_list, list)
+ {
+ if
(avcpu->vc->domain->domain_id == 0)
+ {
+
dom0_task = avcpu->vc;
+ }
+ else if
(vcpu_runnable(avcpu->vc))
+ {
+
new_task = avcpu->vc;
+ }
+ }
+
+ if (new_task == NULL)
+ {
+ /* no non-dom0
runnable task was found */
+ if (dom0_task !=
NULL && vcpu_runnable(dom0_task))
+ {
+
/* if domain 0 has credit left and is runnable, run it */
+ new_task
= dom0_task;
+ }
+ else
+ {
+
/* otherwise just run the idle task */
+
new_task = IDLETASK(cpu);
+ }
+ }
+
+ return new_task;
+}
+
+/*
+ * Xen scheduler callback function to select a VCPU to run.
+ * This is the main scheduler routine.
+ */
+static struct task_slice arinc653_do_schedule(s_time_t t)
+{
+ arinc653_vcpu_t *
avcpu;
/* loop index variable */
+ struct task_slice
ret;
/* hold the chosen domain */
+ struct vcpu * new_task = NULL;
+
+ /* current_task holds a pointer to the
currently executing VCPU across
+ * do_schedule invocations for
credit accounting */
+ static struct vcpu * current_task =
NULL;
+
+ if (unlikely(next_major_frame ==
0)) /* first run of do_schedule */
+ {
+ next_major_frame
= t + arinc653_major_frame;
+ }
+ else if (t >=
next_major_frame)
/* entered a new major frame */
+ {
+ next_major_frame
= t + arinc653_major_frame;
+ /* move
everything that had expired last major frame to
+ * the run
list for this frame */
+
list_splice_init(&expired_list, &run_list);
+
list_for_each_entry(avcpu, &run_list, list)
+ {
+
/* restore domain credits for the new major frame */
+
avcpu->time_left = avcpu->runtime;
+
BUG_ON(avcpu->time_left <= 0);
+ }
+
list_for_each_entry(avcpu, &blocked_list, list)
+ {
+
/* restore domain credits for the new major frame */
+
avcpu->time_left = avcpu->runtime;
+
BUG_ON(avcpu->time_left <= 0);
+ }
+ }
+ else if (AVCPU(current_task) !=
NULL) /* not the idle task */
+ {
+ /*
+ * The
first time this function is called one of the previous if
+ *
statements will be true, and so current_task will get set
+ * to a
non-NULL value before this function is called again.
+ *
next_major_frame starts out as 0, so if it is not changed
+ * the
first if statement will be true.
+ * If
next_major_frame was changed from 0, it must have been
+ * changed
in the arinc653_sched_set() function, since that
+ * is the only
function other than this one that changes that
+ *
variable. In that case, it was set to the time at which
+ *
arinc653_sched_set() was called, and so when this function
+ * is
called the time will be greater than or equal to
+ *
next_major_frame, and so the second if statement will be true.
+ */
+
+ /* we did not
enter a new major frame, so decrease the
+ * credits
remaining for this domain for this frame */
+
AVCPU(current_task)->time_left -=
+
t - AVCPU(current_task)->last_activation_time;
+ if
(AVCPU(current_task)->time_left <= 0)
+ {
+
/* this domain has expended all of its time, so move it
+
* to the expired list */
+
AVCPU(current_task)->time_left = 0;
+
list_move(&AVCPU(current_task)->list, &expired_list);
+ }
+ }
+ else
+ {
+ /* only the idle
VCPU will get here, and we do not do any
+ *
"credit" accounting for it */
+ BUG_ON(!is_idle_vcpu(current_task));
+ }
+
+ new_task = find_next_runnable_vcpu();
+ BUG_ON(new_task == NULL);
+
+ /* if we are switching to a task that we
are tracking
+ * information for, set its last
activation time */
+ if (AVCPU(new_task) != NULL)
+ {
+
AVCPU(new_task)->last_activation_time = t;
+
BUG_ON(AVCPU(new_task)->time_left <= 0);
+ }
+
+ /* Check to make sure we did not miss a
major frame.
+ * This is a good test for robust
partitioning. */
+ BUG_ON(t >= next_major_frame);
+
+ ret.time = is_idle_vcpu(new_task)
+ ?
next_major_frame - t /* run idle task until next
major frame */
+ :
AVCPU(new_task)->time_left; /* run for entire slice this frame
*/
+ ret.task = new_task;
+ current_task = new_task;
+
+ BUG_ON(ret.time <= 0);
+
+ return ret;
+}
+
+/* Xen scheduler callback function to select a CPU for the
VCPU to run on */
+static int arinc653_pick_cpu(struct vcpu * v)
+{
+ /* this implementation only supports one
physical CPU */
+ return 0;
+}
+
+/*
+ * Xen scheduler callback function to wake up a VCPU
+ * Xen may call this scheduler callback function for VCPUs
that are
+ * not in the current ARINC653 run list. We keep track of
the fact
+ * that they have been "woken up" but we still do
not let them run.
+ *
+ * If the VCPU is not in the current schedule:
+ * Move it to the deactivated run list.
+ * Otherwise:
+ * If the VCPU still has credit left for this
major frame:
+ * Move the VCPU to the run list
+ * Otherwise:
+ * Move the VCPU to the expired
list
+ */
+static void arinc653_vcpu_wake(struct vcpu * vc)
+{
+ /* boolean flag to indicate first run */
+ static bool_t dont_raise_softirq = 0;
+
+ if (AVCPU(vc) != NULL) /* check
that this is a VCPU we are tracking */
+ {
+ if
(AVCPU(vc)->active)
+ {
+
/* the VCPU is in the current ARINC653 schedule */
+
if (AVCPU(vc)->time_left > 0)
+
{
+
/* the domain has credit remaining for this frame
+
* so put it on the run list */
+
list_move(&AVCPU(vc)->list, &run_list);
+
}
+
else
+
{
+
/* otherwise put it on the expired list for next frame */
+
list_move(&AVCPU(vc)->list, &expired_list);
+
}
+ }
+ else
+ {
+
/* VCPU is not allowed to run according to this schedule! */
+
list_move(&AVCPU(vc)->list, &deactivated_run_list);
+ }
+ }
+
+ /* the first time the vcpu_wake function
is called, we should raise
+ * a softirq to invoke the
do_scheduler callback */
+ if (!dont_raise_softirq)
+ {
+
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
+ dont_raise_softirq
= 1;
+ }
+}
+
+/*
+ * Xen scheduler callback function to sleep a VCPU
+ * This function will remove the VCPU from the run list.
+ * If the VCPU is in the current schedule:
+ * Move it to the blocked list.
+ * Otherwise:
+ * Move it to the deactivated blocked list.
+ */
+static void arinc653_vcpu_sleep(struct vcpu * vc)
+{
+ if (AVCPU(vc) != NULL) /* check
that this is a VCPU we are tracking */
+ {
+ if
(AVCPU(vc)->active)
/* if in current schedule */
+ {
+
list_move(&AVCPU(vc)->list, &blocked_list);
+ }
+ else
+ {
+
list_move(&AVCPU(vc)->list, &deactivated_blocked_list);
+ }
+ }
+
+ /* if the VCPU being put to sleep is the
same one that is currently
+ * running, raise a softirq to
invoke the scheduler to switch domains */
+ if (per_cpu(schedule_data,
vc->processor).curr == vc)
+ {
+
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
+ }
+}
+
+/*
+ * This structure defines our scheduler for Xen.
+ * The entries tell Xen where to find our
scheduler-specific
+ * callback functions.
+ * The symbol must be visible to the rest of Xen at link
time.
+ */
+struct scheduler sched_arinc653_def = {
+
.name = "ARINC
653 Scheduler",
+
.opt_name = "arinc653",
+
.sched_id = XEN_SCHEDULER_ARINC653,
+
+ .init_domain = NULL,
+ .destroy_domain = NULL,
+
+ .init_vcpu
= arinc653_init_vcpu,
+ .destroy_vcpu =
arinc653_destroy_vcpu,
+
+ .do_schedule =
arinc653_do_schedule,
+
.pick_cpu = arinc653_pick_cpu,
+ .dump_cpu_state = NULL,
+
.sleep =
arinc653_vcpu_sleep,
+
.wake =
arinc653_vcpu_wake,
+
.adjust = NULL,
+};
diff -rupN a/xen/common/schedule.c b/xen/common/schedule.c
--- a/xen/common/schedule.c 2009-08-06
09:57:27.000000000 -0400
+++ b/xen/common/schedule.c 2010-03-19
09:13:50.792881300 -0400
@@ -7,7 +7,8 @@
* File:
common/schedule.c
* Author: Rolf
Neugebauer & Keir Fraser
*
Updated for generic API by Mark Williamson
- *
+
*
ARINC653 scheduler added by DornerWorks
+ *
* Description: Generic CPU scheduling code
*
implements support functionality for the Xen scheduler API.
*
@@ -25,6 +26,7 @@
#include <xen/timer.h>
#include <xen/perfc.h>
#include <xen/sched-if.h>
+#include <xen/sched_arinc653.h>
#include <xen/softirq.h>
#include <xen/trace.h>
#include <xen/mm.h>
@@ -58,9 +60,11 @@ DEFINE_PER_CPU(struct schedule_data, sch
extern struct scheduler sched_sedf_def;
extern struct scheduler sched_credit_def;
+extern struct scheduler sched_arinc653_def;
static struct scheduler *schedulers[] = {
&sched_sedf_def,
&sched_credit_def,
+ &sched_arinc653_def,
NULL
};
@@ -657,6 +661,27 @@ ret_t do_sched_op(int cmd,
XEN_GUEST_HAN
break;
}
+ case SCHEDOP_arinc653_sched_set:
+ {
+
sched_arinc653_sched_set_t sched_set;
+
+ if
(!IS_PRIV(current->domain))
+ {
+
ret = -EPERM;
+
break;
+ }
+
+ if
(copy_from_guest(&sched_set, arg, 1) != 0)
+ {
+
ret = -EFAULT;
+
break;
+ }
+
+ ret = arinc653_sched_set(&sched_set);
+
+ break;
+ }
+
default:
ret =
-ENOSYS;
}
diff -rupN a/xen/include/public/domctl.h
b/xen/include/public/domctl.h
--- a/xen/include/public/domctl.h 2009-08-06
09:57:28.000000000 -0400
+++ b/xen/include/public/domctl.h 2010-03-19
09:15:27.229190500 -0400
@@ -23,6 +23,8 @@
*
* Copyright (c) 2002-2003, B Dragovic
* Copyright (c) 2002-2006, K Fraser
+ *
+ * ARINC653 Scheduler type added by DornerWorks
<DornerWorks.com>.
*/
#ifndef __XEN_PUBLIC_DOMCTL_H__
@@ -297,6 +299,7 @@ DEFINE_XEN_GUEST_HANDLE(xen_domctl_max_v
/* Scheduler types. */
#define XEN_SCHEDULER_SEDF 4
#define XEN_SCHEDULER_CREDIT 5
+#define XEN_SCHEDULER_ARINC653 6
/* Set or get info? */
#define XEN_DOMCTL_SCHEDOP_putinfo 0
#define XEN_DOMCTL_SCHEDOP_getinfo 1
diff -rupN a/xen/include/public/sched.h
b/xen/include/public/sched.h
--- a/xen/include/public/sched.h 2009-08-06
09:57:28.000000000 -0400
+++ b/xen/include/public/sched.h 2010-03-19
09:15:17.682315500 -0400
@@ -22,6 +22,8 @@
* DEALINGS IN THE SOFTWARE.
*
* Copyright (c) 2005, Keir Fraser <keir@xxxxxxxxxxxxx>
+ *
+ * ARINC653 Schedule set added by DornerWorks
<DornerWorks.com>.
*/
#ifndef __XEN_PUBLIC_SCHED_H__
@@ -108,6 +110,40 @@ DEFINE_XEN_GUEST_HANDLE(sched_remote_shu
#define SHUTDOWN_suspend 2 /*
Clean up, save suspend info,
kill. */
#define SHUTDOWN_crash
3 /* Tell controller we've
crashed.
*/
+/*
+ * Set the ARINC653 schedule. The new schedule takes effect
immediately.
+ * The scheduler does not wait for the current major frame
to expire
+ * before switching to the new schedule.
+ */
+#define
SCHEDOP_arinc653_sched_set 5
+#define ARINC653_MAX_DOMAINS_PER_SCHEDULE 64
+/*
+ * This structure is used to pass a new ARINC653 schedule
from a
+ * privileged domain (ie dom0) to Xen.
+ */
+struct sched_arinc653_sched_set {
+ /* major_frame holds the time for the
new schedule's major frame
+ * in nanoseconds. */
+ int64_t
major_frame;
+ /* num_sched_entries holds how many of
the entries in the
+ * sched_entries[] array are valid.
*/
+ uint8_t
num_sched_entries;
+ /* The sched_entries array holds the
actual schedule entries. */
+ struct {
+ /* dom_handle
must match a domain's UUID */
+
xen_domain_handle_t dom_handle;
+ /* If a domain
has multiple VCPUs, vcpu_id specifies which one
+ * this
schedule entry applies to. It should be set to 0 if
+ * there is
only one VCPU for the domain. */
+
int
vcpu_id;
+ /* runtime
specifies the amount of time that should be allocated
+ * to this
VCPU per major frame. It is specified in nanoseconds */
+
int64_t runtime;
+ }
sched_entries[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
+};
+typedef struct sched_arinc653_sched_set
sched_arinc653_sched_set_t;
+DEFINE_XEN_GUEST_HANDLE(sched_arinc653_sched_set_t);
+
#endif /* __XEN_PUBLIC_SCHED_H__ */
/*
diff -rupN a/xen/include/xen/sched_arinc653.h
b/xen/include/xen/sched_arinc653.h
--- a/xen/include/xen/sched_arinc653.h 1969-12-31
19:00:00.000000000 -0500
+++ b/xen/include/xen/sched_arinc653.h 2010-03-19
08:58:10.346112800 -0400
@@ -0,0 +1,44 @@
+/*
+ * File: sched_arinc653.h
+ * Copyright (c) 2009, DornerWorks, Ltd.
<DornerWorks.com>
+ *
+ * Description:
+ * This file prototypes global ARINC653
scheduler functions. Scheduler
+ * callback functions are static to the
sched_arinc653 module and do not
+ * need global prototypes here.
+ *
+ * This program 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.
+ *
+ * This program 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.
+ */
+
+#ifndef __SCHED_ARINC653_H__
+#define __SCHED_ARINC653_H__
+
+#include <public/sched.h>
+
+/*
+ * arinc653_sched_set() is used to put a new schedule in
place for the
+ * ARINC653 scheduler.
+ * Whereas the credit scheduler allows configuration by
changing weights
+ * and caps on a per-domain basis, the ARINC653 scheduler
allows configuring
+ * a complete list of domains that are allowed to run, and
the duration they
+ * are allowed to run.
+ * This is a global call instead of a domain-specific
setting, so a prototype
+ * is placed here for the rest of Xen to access. Currently
it is only
+ * called by the do_sched_op() function in
xen/common/schedule.c
+ * in response to a hypercall.
+ *
+ * Return values:
+ *
0 Success
+ * -EINVAL Invalid Parameter
+ */
+int arinc653_sched_set(sched_arinc653_sched_set_t *
schedule);
+
+#endif /* __SCHED_ARINC653_H__ */
