d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/i40e: support adding TM node

Browse Source 
Add the support of the Traffic Management API,
rte_tm_node_add.

Signed-off-by: Wenzhuo Lu <wenzhuo.lu@intel.com>
This commit is contained in:
Wenzhuo Lu 2017-06-29 12:23:42 +08:00 committed by Cristian Dumitrescu
parent 2d472efc64
commit 03a249b62b
3 changed files with 374 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/net/i40e/i40e_ethdev.c
View File

@ -2093,6 +2093,9 @@ i40e_dev_stop(struct rte_eth_dev *dev)
rte_free(intr_handle->intr_vec);
intr_handle->intr_vec = NULL;
}
/* reset hierarchy commit */
pf->tm_conf.committed = false;
}
static void

46
drivers/net/i40e/i40e_ethdev.h
View File

@ -662,9 +662,55 @@ struct i40e_tm_shaper_profile {
TAILQ_HEAD(i40e_shaper_profile_list, i40e_tm_shaper_profile);
/* node type of Traffic Manager */
enum i40e_tm_node_type {
I40E_TM_NODE_TYPE_PORT,
I40E_TM_NODE_TYPE_TC,
I40E_TM_NODE_TYPE_QUEUE,
I40E_TM_NODE_TYPE_MAX,
};
/* Struct to store Traffic Manager node configuration. */
struct i40e_tm_node {
TAILQ_ENTRY(i40e_tm_node) node;
uint32_t id;
uint32_t priority;
uint32_t weight;
uint32_t reference_count;
struct i40e_tm_node *parent;
struct i40e_tm_shaper_profile *shaper_profile;
struct rte_tm_node_params params;
};
TAILQ_HEAD(i40e_tm_node_list, i40e_tm_node);
/* Struct to store all the Traffic Manager configuration. */
struct i40e_tm_conf {
struct i40e_shaper_profile_list shaper_profile_list;
struct i40e_tm_node *root; /* root node - port */
struct i40e_tm_node_list tc_list; /* node list for all the TCs */
struct i40e_tm_node_list queue_list; /* node list for all the queues */
/**
* The number of added TC nodes.
* It should be no more than the TC number of this port.
*/
uint32_t nb_tc_node;
/**
* The number of added queue nodes.
* It should be no more than the queue number of this port.
*/
uint32_t nb_queue_node;
/**
* This flag is used to check if APP can change the TM node
* configuration.
* When it's true, means the configuration is applied to HW,
* APP should not change the configuration.
* As we don't support on-the-fly configuration, when starting
* the port, APP should call the hierarchy_commit API to set this
* flag to true. When stopping the port, this flag should be set
* to false.
*/
bool committed;
};
/*

325
drivers/net/i40e/i40e_tm.c
View File

@ -46,11 +46,17 @@ static int i40e_shaper_profile_add(struct rte_eth_dev *dev,
static int i40e_shaper_profile_del(struct rte_eth_dev *dev,
uint32_t shaper_profile_id,
struct rte_tm_error *error);
static int i40e_node_add(struct rte_eth_dev *dev, uint32_t node_id,
uint32_t parent_node_id, uint32_t priority,
uint32_t weight, uint32_t level_id,
struct rte_tm_node_params *params,
struct rte_tm_error *error);
const struct rte_tm_ops i40e_tm_ops = {
.capabilities_get = i40e_tm_capabilities_get,
.shaper_profile_add = i40e_shaper_profile_add,
.shaper_profile_delete = i40e_shaper_profile_del,
.node_add = i40e_node_add,
};
int
@ -72,6 +78,14 @@ i40e_tm_conf_init(struct rte_eth_dev *dev)
/* initialize shaper profile list */
TAILQ_INIT(&pf->tm_conf.shaper_profile_list);
/* initialize node configuration */
pf->tm_conf.root = NULL;
TAILQ_INIT(&pf->tm_conf.tc_list);
TAILQ_INIT(&pf->tm_conf.queue_list);
pf->tm_conf.nb_tc_node = 0;
pf->tm_conf.nb_queue_node = 0;
pf->tm_conf.committed = false;
}
void
@ -79,6 +93,23 @@ i40e_tm_conf_uninit(struct rte_eth_dev *dev)
{
struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
struct i40e_tm_shaper_profile *shaper_profile;
struct i40e_tm_node *tm_node;
/* clear node configuration */
while ((tm_node = TAILQ_FIRST(&pf->tm_conf.queue_list))) {
TAILQ_REMOVE(&pf->tm_conf.queue_list, tm_node, node);
rte_free(tm_node);
}
pf->tm_conf.nb_queue_node = 0;
while ((tm_node = TAILQ_FIRST(&pf->tm_conf.tc_list))) {
TAILQ_REMOVE(&pf->tm_conf.tc_list, tm_node, node);
rte_free(tm_node);
}
pf->tm_conf.nb_tc_node = 0;
if (pf->tm_conf.root) {
rte_free(pf->tm_conf.root);
pf->tm_conf.root = NULL;
}
/* Remove all shaper profiles */
while ((shaper_profile =
@ -290,3 +321,297 @@ i40e_shaper_profile_del(struct rte_eth_dev *dev,
return 0;
}
static inline struct i40e_tm_node *
i40e_tm_node_search(struct rte_eth_dev *dev,
uint32_t node_id, enum i40e_tm_node_type *node_type)
{
struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
struct i40e_tm_node_list *queue_list = &pf->tm_conf.queue_list;
struct i40e_tm_node_list *tc_list = &pf->tm_conf.tc_list;
struct i40e_tm_node *tm_node;
if (pf->tm_conf.root && pf->tm_conf.root->id == node_id) {
*node_type = I40E_TM_NODE_TYPE_PORT;
return pf->tm_conf.root;
}
TAILQ_FOREACH(tm_node, tc_list, node) {
if (tm_node->id == node_id) {
*node_type = I40E_TM_NODE_TYPE_TC;
return tm_node;
}
}
TAILQ_FOREACH(tm_node, queue_list, node) {
if (tm_node->id == node_id) {
*node_type = I40E_TM_NODE_TYPE_QUEUE;
return tm_node;
}
}
return NULL;
}
static int
i40e_node_param_check(uint32_t node_id, uint32_t parent_node_id,
uint32_t priority, uint32_t weight,
struct rte_tm_node_params *params,
struct rte_tm_error *error)
{
if (node_id == RTE_TM_NODE_ID_NULL) {
error->type = RTE_TM_ERROR_TYPE_NODE_ID;
error->message = "invalid node id";
return -EINVAL;
}
if (priority) {
error->type = RTE_TM_ERROR_TYPE_NODE_PRIORITY;
error->message = "priority should be 0";
return -EINVAL;
}
if (weight != 1) {
error->type = RTE_TM_ERROR_TYPE_NODE_WEIGHT;
error->message = "weight must be 1";
return -EINVAL;
}
/* not support shared shaper */
if (params->shared_shaper_id) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_SHAPER_ID;
error->message = "shared shaper not supported";
return -EINVAL;
}
if (params->n_shared_shapers) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS;
error->message = "shared shaper not supported";
return -EINVAL;
}
/* for root node */
if (parent_node_id == RTE_TM_NODE_ID_NULL) {
if (params->nonleaf.wfq_weight_mode) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE;
error->message = "WFQ not supported";
return -EINVAL;
}
if (params->nonleaf.n_sp_priorities != 1) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SP_PRIORITIES;
error->message = "SP priority not supported";
return -EINVAL;
} else if (params->nonleaf.wfq_weight_mode &&
!(*params->nonleaf.wfq_weight_mode)) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE;
error->message = "WFP should be byte mode";
return -EINVAL;
}
return 0;
}
/* for TC or queue node */
if (params->leaf.cman) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_CMAN;
error->message = "Congestion management not supported";
return -EINVAL;
}
if (params->leaf.wred.wred_profile_id !=
RTE_TM_WRED_PROFILE_ID_NONE) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_WRED_PROFILE_ID;
error->message = "WRED not supported";
return -EINVAL;
}
if (params->leaf.wred.shared_wred_context_id) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_WRED_CONTEXT_ID;
error->message = "WRED not supported";
return -EINVAL;
}
if (params->leaf.wred.n_shared_wred_contexts) {
error->type =
RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_WRED_CONTEXTS;
error->message = "WRED not supported";
return -EINVAL;
}
return 0;
}
/**
* Now the TC and queue configuration is controlled by DCB.
* We need check if the node configuration follows the DCB configuration.
* In the future, we may use TM to cover DCB.
*/
static int
i40e_node_add(struct rte_eth_dev *dev, uint32_t node_id,
uint32_t parent_node_id, uint32_t priority,
uint32_t weight, uint32_t level_id,
struct rte_tm_node_params *params,
struct rte_tm_error *error)
{
struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
enum i40e_tm_node_type node_type = I40E_TM_NODE_TYPE_MAX;
enum i40e_tm_node_type parent_node_type = I40E_TM_NODE_TYPE_MAX;
struct i40e_tm_shaper_profile *shaper_profile;
struct i40e_tm_node *tm_node;
struct i40e_tm_node *parent_node;
uint16_t tc_nb = 0;
int ret;
if (!params || !error)
return -EINVAL;
/* if already committed */
if (pf->tm_conf.committed) {
error->type = RTE_TM_ERROR_TYPE_UNSPECIFIED;
error->message = "already committed";
return -EINVAL;
}
ret = i40e_node_param_check(node_id, parent_node_id, priority, weight,
params, error);
if (ret)
return ret;
/* check if the node ID is already used */
if (i40e_tm_node_search(dev, node_id, &node_type)) {
error->type = RTE_TM_ERROR_TYPE_NODE_ID;
error->message = "node id already used";
return -EINVAL;
}
/* check the shaper profile id */
shaper_profile = i40e_shaper_profile_search(dev,
params->shaper_profile_id);
if (!shaper_profile) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_SHAPER_PROFILE_ID;
error->message = "shaper profile not exist";
return -EINVAL;
}
/* root node if not have a parent */
if (parent_node_id == RTE_TM_NODE_ID_NULL) {
/* check level */
if (level_id != RTE_TM_NODE_LEVEL_ID_ANY &&
level_id > I40E_TM_NODE_TYPE_PORT) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
error->message = "Wrong level";
return -EINVAL;
}
/* obviously no more than one root */
if (pf->tm_conf.root) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
error->message = "already have a root";
return -EINVAL;
}
/* add the root node */
tm_node = rte_zmalloc("i40e_tm_node",
sizeof(struct i40e_tm_node),
0);
if (!tm_node)
return -ENOMEM;
tm_node->id = node_id;
tm_node->priority = priority;
tm_node->weight = weight;
tm_node->reference_count = 0;
tm_node->parent = NULL;
tm_node->shaper_profile = shaper_profile;
(void)rte_memcpy(&tm_node->params, params,
sizeof(struct rte_tm_node_params));
pf->tm_conf.root = tm_node;
/* increase the reference counter of the shaper profile */
shaper_profile->reference_count++;
return 0;
}
/* TC or queue node */
/* check the parent node */
parent_node = i40e_tm_node_search(dev, parent_node_id,
&parent_node_type);
if (!parent_node) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
error->message = "parent not exist";
return -EINVAL;
}
if (parent_node_type != I40E_TM_NODE_TYPE_PORT &&
parent_node_type != I40E_TM_NODE_TYPE_TC) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
error->message = "parent is not port or TC";
return -EINVAL;
}
/* check level */
if (level_id != RTE_TM_NODE_LEVEL_ID_ANY &&
level_id != parent_node_type + 1) {
error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
error->message = "Wrong level";
return -EINVAL;
}
/* check the node number */
if (parent_node_type == I40E_TM_NODE_TYPE_PORT) {
/* check the TC number */
tc_nb = i40e_tc_nb_get(dev);
if (pf->tm_conf.nb_tc_node >= tc_nb) {
error->type = RTE_TM_ERROR_TYPE_NODE_ID;
error->message = "too many TCs";
return -EINVAL;
}
} else {
/* check the queue number */
if (pf->tm_conf.nb_queue_node >= hw->func_caps.num_tx_qp) {
error->type = RTE_TM_ERROR_TYPE_NODE_ID;
error->message = "too many queues";
return -EINVAL;
}
/**
* check the node id.
* For queue, the node id means queue id.
*/
if (node_id >= hw->func_caps.num_tx_qp) {
error->type = RTE_TM_ERROR_TYPE_NODE_ID;
error->message = "too large queue id";
return -EINVAL;
}
}
/* add the TC or queue node */
tm_node = rte_zmalloc("i40e_tm_node",
sizeof(struct i40e_tm_node),
0);
if (!tm_node)
return -ENOMEM;
tm_node->id = node_id;
tm_node->priority = priority;
tm_node->weight = weight;
tm_node->reference_count = 0;
tm_node->parent = pf->tm_conf.root;
tm_node->shaper_profile = shaper_profile;
(void)rte_memcpy(&tm_node->params, params,
sizeof(struct rte_tm_node_params));
if (parent_node_type == I40E_TM_NODE_TYPE_PORT) {
TAILQ_INSERT_TAIL(&pf->tm_conf.tc_list,
tm_node, node);
pf->tm_conf.nb_tc_node++;
} else {
TAILQ_INSERT_TAIL(&pf->tm_conf.queue_list,
tm_node, node);
pf->tm_conf.nb_queue_node++;
}
tm_node->parent->reference_count++;
/* increase the reference counter of the shaper profile */
shaper_profile->reference_count++;
return 0;
}