examples/ip_pipeline/tmgr.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2018 Intel Corporation
 */
 
#include <stdlib.h>
 
#include <rte_common.h>
#include <rte_string_fns.h>
 
#include "tmgr.h"
 
static struct rte_sched_subport_profile_params
    subport_profile[TMGR_SUBPORT_PROFILE_MAX];
 
static uint32_t n_subport_profiles;
 
static struct rte_sched_pipe_params
    pipe_profile[TMGR_PIPE_PROFILE_MAX];
 
static uint32_t n_pipe_profiles;
 
static const struct rte_sched_subport_params subport_params_default = {
    .n_pipes_per_subport_enabled = 0, /* filled at runtime */
    .qsize = {64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64},
    .pipe_profiles = pipe_profile,
    .n_pipe_profiles = 0, /* filled at run time */
    .n_max_pipe_profiles = RTE_DIM(pipe_profile),
    .cman_params = NULL,
};
 
static struct tmgr_port_list tmgr_port_list;
 
int
tmgr_init(void)
{
    TAILQ_INIT(&tmgr_port_list);
 
    return 0;
}
 
struct tmgr_port *
tmgr_port_find(const char *name)
{
    struct tmgr_port *tmgr_port;
 
    if (name == NULL)
        return NULL;
 
    TAILQ_FOREACH(tmgr_port, &tmgr_port_list, node)
        if (strcmp(tmgr_port->name, name) == 0)
            return tmgr_port;
 
    return NULL;
}
 
int
tmgr_subport_profile_add(struct rte_sched_subport_profile_params *params)
{
    /* Check input params */
    if (params == NULL)
        return -1;
 
    /* Save profile */
    memcpy(&subport_profile[n_subport_profiles],
        params,
        sizeof(*params));
 
    n_subport_profiles++;
 
    return 0;
}
 
int
tmgr_pipe_profile_add(struct rte_sched_pipe_params *p)
{
    /* Check input params */
    if (p == NULL)
        return -1;
 
    /* Save profile */
    memcpy(&pipe_profile[n_pipe_profiles],
        p,
        sizeof(*p));
 
    n_pipe_profiles++;
 
    return 0;
}
 
struct tmgr_port *
tmgr_port_create(const char *name, struct tmgr_port_params *params)
{
    struct rte_sched_subport_params subport_params;
    struct rte_sched_port_params p;
    struct tmgr_port *tmgr_port;
    struct rte_sched_port *s;
    uint32_t i, j;
 
    /* Check input params */
    if ((name == NULL) ||
        tmgr_port_find(name) ||
        (params == NULL) ||
        (params->n_subports_per_port == 0) ||
        (params->n_pipes_per_subport == 0) ||
        (params->cpu_id >= RTE_MAX_NUMA_NODES) ||
        (n_subport_profiles == 0) ||
        (n_pipe_profiles == 0))
        return NULL;
 
    /* Resource create */
    p.name = name;
    p.socket = (int) params->cpu_id;
    p.rate = params->rate;
    p.mtu = params->mtu;
    p.frame_overhead = params->frame_overhead;
    p.n_subports_per_port = params->n_subports_per_port;
    p.n_subport_profiles = n_subport_profiles;
    p.subport_profiles = subport_profile;
    p.n_max_subport_profiles = TMGR_SUBPORT_PROFILE_MAX;
    p.n_pipes_per_subport = params->n_pipes_per_subport;
 
 
    s = rte_sched_port_config(&p);
    if (s == NULL)
        return NULL;
 
    memcpy(&subport_params, &subport_params_default,
        sizeof(subport_params_default));
 
    subport_params.n_pipe_profiles = n_pipe_profiles;
    subport_params.n_pipes_per_subport_enabled =
                        params->n_pipes_per_subport;
 
    for (i = 0; i < params->n_subports_per_port; i++) {
        int status;
 
        status = rte_sched_subport_config(
            s,
            i,
            &subport_params,
            0);
 
        if (status) {
            rte_sched_port_free(s);
            return NULL;
        }
 
        for (j = 0; j < params->n_pipes_per_subport; j++) {
 
            status = rte_sched_pipe_config(
                s,
                i,
                j,
                0);
 
            if (status) {
                rte_sched_port_free(s);
                return NULL;
            }
        }
    }
 
    /* Node allocation */
    tmgr_port = calloc(1, sizeof(struct tmgr_port));
    if (tmgr_port == NULL) {
        rte_sched_port_free(s);
        return NULL;
    }
 
    /* Node fill in */
    strlcpy(tmgr_port->name, name, sizeof(tmgr_port->name));
    tmgr_port->s = s;
    tmgr_port->n_subports_per_port = params->n_subports_per_port;
    tmgr_port->n_pipes_per_subport = params->n_pipes_per_subport;
 
    /* Node add to list */
    TAILQ_INSERT_TAIL(&tmgr_port_list, tmgr_port, node);
 
    return tmgr_port;
}
 
int
tmgr_subport_config(const char *port_name,
    uint32_t subport_id,
    uint32_t subport_profile_id)
{
    struct tmgr_port *port;
    int status;
 
    /* Check input params */
    if (port_name == NULL)
        return -1;
 
    port = tmgr_port_find(port_name);
    if ((port == NULL) ||
        (subport_id >= port->n_subports_per_port) ||
        (subport_profile_id >= n_subport_profiles))
        return -1;
 
    /* Resource config */
    status = rte_sched_subport_config(
        port->s,
        subport_id,
        NULL,
        subport_profile_id);
 
    return status;
}
 
int
tmgr_pipe_config(const char *port_name,
    uint32_t subport_id,
    uint32_t pipe_id_first,
    uint32_t pipe_id_last,
    uint32_t pipe_profile_id)
{
    struct tmgr_port *port;
    uint32_t i;
 
    /* Check input params */
    if (port_name == NULL)
        return -1;
 
    port = tmgr_port_find(port_name);
    if ((port == NULL) ||
        (subport_id >= port->n_subports_per_port) ||
        (pipe_id_first >= port->n_pipes_per_subport) ||
        (pipe_id_last >= port->n_pipes_per_subport) ||
        (pipe_id_first > pipe_id_last) ||
        (pipe_profile_id >= n_pipe_profiles))
        return -1;
 
    /* Resource config */
    for (i = pipe_id_first; i <= pipe_id_last; i++) {
        int status;
 
        status = rte_sched_pipe_config(
            port->s,
            subport_id,
            i,
            (int) pipe_profile_id);
 
        if (status)
            return status;
    }
 
    return 0;
}