net/i40e: support adding TM node

Add the support of the Traffic Management API,
rte_tm_node_add.

Signed-off-by: Wenzhuo Lu <wenzhuo.lu@intel.com>

diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index b423f5d..0091511 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -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

diff --git a/drivers/net/i40e/i40e_ethdev.h b/drivers/net/i40e/i40e_ethdev.h
index af035cb..38a86f6 100644 (file)
--- a/drivers/net/i40e/i40e_ethdev.h
+++ b/drivers/net/i40e/i40e_ethdev.h
@@ -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;
 };
 
 /*

diff --git a/drivers/net/i40e/i40e_tm.c b/drivers/net/i40e/i40e_tm.c
index 67df701..3017185 100644 (file)
--- a/drivers/net/i40e/i40e_tm.c
+++ b/drivers/net/i40e/i40e_tm.c
@@ -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;
+}