Re: [Xen-devel] [PATCH 1/1] Xen ARINC653 scheduler

[George Dunlap <George.Dunlap@xxxxxxxxxxxxx>]

What is ARINC653?  Can you give a summary of what it is, why it's
important, and what this patch does?

Thanks,
 -George

On Fri, Mar 19, 2010 at 4:23 PM, Anthony Boorsma
<Anthony.Boorsma@xxxxxxxxxxxxxxx> wrote:
> 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__ */
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@xxxxxxxxxxxxxxxxxxx
> http://lists.xensource.com/xen-devel
>
>

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel