rt_scheduler_rk.c

Go to the documentation of this file.

/*
 * rt_scheduler_rk.c
 *
 * Copyright (c) 2004 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rt_scheduler_rk.c
 *
 * TimeSys Linux implementation of the rt_scheduler interface.
 */

#include "config.h"

#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <rk.h>
#include <rk_util.h>
#include <rt_scheduler.h>
#include <assert_pp.h>

enum {
    RSRB_OWNER,
};

enum {
    /** The schedulable owns the resource set, it was not discovered. */
    RSRF_OWNER = (1L << RSRB_OWNER),
};

/**
 * The TimeSys implementation of a schedulable.
 *
 * rsr_ResourceSet - The resource set this schedulable maps to.
 * rsr_CPUReserve - The CPU reserve connected to the resource set or NULL if
 * one has not yet been attached.
 * rsr_Flags - Field used to store any RSRF_ flags.
 */
typedef struct rts_schedulable_rk {
    rk_resource_set_t rsr_ResourceSet;
    rk_reserve_t rsr_CPUReserve;
    unsigned long rsr_Flags;
} *rts_schedulable_rk_t;

/**
 * "Repair" the system by deleting any resource sets that have a CPU reserve
 * but no processes.
 */
static void rts_repair_resource_sets(void)
{
#define MAX_RK_SETS 128
    static rk_resource_set_t rk_sets[MAX_RK_SETS];
    
    unsigned int lpc, actual;

    actual = rk_resource_sets_get_list(rk_sets, MAX_RK_SETS);
    for( lpc = 0; lpc < actual; lpc++ )
    {
        int proc_count = rk_resource_set_get_num_procs(rk_sets[lpc]);
        rk_reserve_t cr = rk_resource_set_get_cpu_rsv(rk_sets[lpc]);
        
        if( (proc_count == 0) && (cr != NULL_RESERVE) )
        {
            rk_resource_set_destroy(rk_sets[lpc]);
            rk_sets[lpc] = NULL_RESOURCE_SET;
        }
    }
#undef MAX_RK_SETS
}

int rts_query_scheduler(rts_scheduler_data_t rsd)
{
    int retval = 0;

    if( rsd == NULL )
    {
        retval = EINVAL;
    }
    else
    {
        rsd->rsd_Flags = RSDF_RESERVATIONS;
        rsd->rsd_MaxReservable = 0.90;
    }
    return( retval );
}

int rts_grab_schedulable(rts_schedulable_t *rs, pid_t member, const char *name)
{
    rts_schedulable_rk_t rsr;
    int retval = 0;

    if( (rs == NULL) || ((member == -1) && (name == NULL)) )
    {
        retval = EINVAL;
    }
    else if( (rsr = calloc(1, sizeof(struct rts_schedulable_rk))) == NULL )
    {
        retval = ENOMEM;
    }
    else
    {
        rk_reserve_t old_reserve;
        
        /* Make sure the world is sane. */
        rts_repair_resource_sets();

        /* Try to get a resource set, */
        if( (rsr->rsr_ResourceSet = rk_proc_get_rset(member)) ==
            NULL_RESOURCE_SET )
        {
            if( (name == NULL) ||
                (rsr->rsr_ResourceSet = rk_resource_set_get_by_name(name)) ==
                NULL_RESOURCE_SET )
            {
                if( name == NULL )
                {
                    name = "rt_schedulable"; // XXX Generate one?
                }
                if( (rsr->rsr_ResourceSet = rk_resource_set_create(name)) ==
                    NULL_RESOURCE_SET )
                {
                    retval = errno;
                }
                else
                {
                    rsr->rsr_Flags |= RSRF_OWNER;
                }
            }
        }

        /* ... make sure it is sane, and then */
        if( (old_reserve =
             rk_resource_set_get_cpu_rsv(rsr->rsr_ResourceSet)) !=
            NULL_RESERVE )
        {
            if( rk_resource_set_get_num_procs(rsr->rsr_ResourceSet) != 0 )
            {
                retval = EBUSY;
            }
            else
            {
                rk_cpu_reserve_delete(rsr->rsr_ResourceSet);
                old_reserve = NULL_RESERVE;
            }
        }
        
        /* ... try to attach our process. */
        if( (retval == 0) && (rsr->rsr_ResourceSet != NULL_RESOURCE_SET) )
        {
            if( (member != -1) &&
                (rk_resource_set_attach_process(rsr->rsr_ResourceSet,
                                                member) == -1) &&
                (errno != EBUSY) )
            {
                /* No joy, something went wrong. */
                retval = errno;
            }
            else
            {
                /* This process is already attached. */
                *rs = rsr;
                rsr = NULL;
            }
        }

        if( rsr != NULL )
        {
            rts_release_schedulable(rsr);
            rsr = NULL;
        }
    }
    return( retval );
}

int rts_release_schedulable(rts_schedulable_t rs)
{
    int retval = 0;

    if( rs == NULL )
    {
        retval = EINVAL;
    }
    else
    {
        {
            rts_schedulable_rk_t rsr = (rts_schedulable_rk_t)rs;
            
            if( rsr->rsr_CPUReserve != NULL_RESERVE )
            {
                rk_cpu_reserve_delete(rsr->rsr_ResourceSet);
            }
            if( rsr->rsr_Flags & RSRF_OWNER )
            {
                rk_resource_set_destroy(rsr->rsr_ResourceSet);
            }
            rsr->rsr_ResourceSet = NULL_RESOURCE_SET;
        }
        free(rs);
        rs = NULL;
    }
    return( retval );
}

int rts_set_schedule(rts_schedulable_t rsa, rts_schedule_t rs)
{
    rts_schedulable_rk_t rsr = (rts_schedulable_rk_t)rsa;
    int retval = 0;

    if( (rsa == NULL) || (rs == NULL) )
    {
        retval = EINVAL;
    }
    else if( rsr->rsr_ResourceSet == NULL_RESOURCE_SET )
    {
        retval = EINVAL;
    }
    else if( (rs->rs_ReserveMode <= RTS_RSV_MIN) ||
             (rs->rs_ReserveMode >= RTS_RSV_MAX) )
    {
        retval = EINVAL;
    }
    else
    {
        struct cpu_reserve_attr cra;

        /* Convert from rt_scheduler to TimeSys and then */
        memset(&cra, 0, sizeof(cra));
        cra.compute_time = rs->rs_ComputeTime;
        cra.period = cra.deadline = rs->rs_Period;
        switch( rs->rs_ReserveMode )
        {
        case RTS_RSV_SOFT:
            cra.reserve_type.sch_mode = RSV_SOFT;
            cra.reserve_type.enf_mode = RSV_SOFT;
            cra.reserve_type.rep_mode = RSV_SOFT;
            break;
        case RTS_RSV_HARD:
            cra.reserve_type.sch_mode = RSV_HARD;
            cra.reserve_type.enf_mode = RSV_HARD;
            cra.reserve_type.rep_mode = RSV_HARD;
            break;
        default:
            ensure(0);
            break;
        }
        cra.processor = RK_ANY_CPU;

        /* ... change the reserve. */
        if( rsr->rsr_CPUReserve == NULL_RESERVE )
        {
            /* No reserve yet, make sure the set is consistent and then */
            if( rk_resource_set_get_cpu_rsv(rsr->rsr_ResourceSet) !=
                NULL_RESERVE )
            {
                retval = EBUSY;
            }
            /* ... create one. */
            else if( rk_cpu_reserve_create(rsr->rsr_ResourceSet,
                                           &rsr->rsr_CPUReserve,
                                           &cra) == -1 )
            {
                retval = errno;
            }
        }
        else
        {
            if( rk_cpu_reserve_ctl(rsr->rsr_ResourceSet, &cra) == -1 )
            {
                retval = errno;
            }
        }
    }
    return( retval );
}

int rts_get_schedule(rts_schedulable_t rsa, rts_schedule_t rs_out)
{
    rts_schedulable_rk_t rsr = (rts_schedulable_rk_t)rsa;
    int retval = 0;

    if( (rsa == NULL) || (rs_out == NULL) )
    {
        retval = EINVAL;
    }
    else if( rsr->rsr_ResourceSet == NULL_RESOURCE_SET )
    {
        retval = EINVAL;
    }
    else
    {
        if( rsr->rsr_CPUReserve == NULL_RESERVE )
        {
            memset(rs_out, 0, sizeof(struct rts_schedule));
        }
        else
        {
            struct cpu_reserve_attr cra;

            /* Try to get the TimeSys schedule and then */
            if( rk_cpu_reserve_get_attr(rsr->rsr_CPUReserve, &cra) == -1 )
            {
                retval = errno;
            }
            /* ... convert it to rt_scheduler format. */
            else
            {
                rs_out->rs_Period = cra.period;
                rs_out->rs_ComputeTime = cra.compute_time;
                switch( cra.reserve_type.sch_mode )
                {
                case RSV_SOFT:
                    rs_out->rs_ReserveMode = RTS_RSV_SOFT;
                    break;
                case RSV_HARD:
                    rs_out->rs_ReserveMode = RTS_RSV_HARD;
                    break;
                default:
                    ensure(0);
                    break;
                }
            }
        }
    }
    return( retval );
}

int rts_clear_schedule(rts_schedulable_t rsa)
{
    rts_schedulable_rk_t rsr = (rts_schedulable_rk_t)rsa;
    int retval = 0;

    if( rsa == NULL )
    {
        retval = EINVAL;
    }
    else if( rsr->rsr_ResourceSet == NULL )
    {
        retval = EINVAL;
    }
    else
    {
        if( rsr->rsr_CPUReserve != NULL_RESERVE )
        {
            rk_cpu_reserve_delete(rsr->rsr_ResourceSet);
            rsr->rsr_CPUReserve = NULL_RESERVE;
        }
    }
    return( retval );
}

---