uint64_t action_flags,
const struct rte_flow_action *action,
const struct rte_flow_attr *attr,
+ bool *def_policy,
struct rte_flow_error *error)
{
struct mlx5_priv *priv = dev->data->dev_private;
const struct rte_flow_action_meter *am = action->conf;
struct mlx5_flow_meter_info *fm;
+ struct mlx5_flow_meter_policy *mtr_policy;
+ struct mlx5_flow_mtr_mng *mtrmng = priv->sh->mtrmng;
if (!am)
return rte_flow_error_set(error, EINVAL,
(!fm->ingress && !attr->ingress && attr->egress) ||
(!fm->egress && !attr->egress && attr->ingress)))
return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, NULL,
+ "Flow attributes domain are either invalid "
+ "or have a domain conflict with current "
+ "meter attributes");
+ if (fm->def_policy) {
+ if (!((attr->transfer &&
+ mtrmng->def_policy[MLX5_MTR_DOMAIN_TRANSFER]) ||
+ (attr->egress &&
+ mtrmng->def_policy[MLX5_MTR_DOMAIN_EGRESS]) ||
+ (attr->ingress &&
+ mtrmng->def_policy[MLX5_MTR_DOMAIN_INGRESS])))
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, NULL,
+ "Flow attributes domain "
+ "have a conflict with current "
+ "meter domain attributes");
+ *def_policy = true;
+ } else {
+ mtr_policy = mlx5_flow_meter_policy_find(dev,
+ fm->policy_id, NULL);
+ if (!mtr_policy)
+ return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION, NULL,
- "Flow attributes are either invalid "
- "or have a conflict with current "
- "meter attributes");
+ "Invalid policy id for meter ");
+ if (!((attr->transfer && mtr_policy->transfer) ||
+ (attr->egress && mtr_policy->egress) ||
+ (attr->ingress && mtr_policy->ingress)))
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ACTION, NULL,
+ "Flow attributes domain "
+ "have a conflict with current "
+ "meter domain attributes");
+ *def_policy = false;
+ }
return 0;
}
.fdb_def_rule = !!priv->fdb_def_rule,
};
const struct rte_eth_hairpin_conf *conf;
+ bool def_policy = false;
if (items == NULL)
return -1;
return rte_flow_error_set(error, ENOTSUP,
RTE_FLOW_ERROR_TYPE_ACTION,
actions, "too many actions");
+ if (action_flags &
+ MLX5_FLOW_ACTION_METER_WITH_TERMINATED_POLICY)
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, "meter action with policy "
+ "must be the last action");
switch (type) {
case RTE_FLOW_ACTION_TYPE_VOID:
break;
ret = mlx5_flow_validate_action_meter(dev,
action_flags,
actions, attr,
+ &def_policy,
error);
if (ret < 0)
return ret;
action_flags |= MLX5_FLOW_ACTION_METER;
+ if (!def_policy)
+ action_flags |=
+ MLX5_FLOW_ACTION_METER_WITH_TERMINATED_POLICY;
++actions_n;
/* Meter action will add one more TAG action. */
rw_act_num += MLX5_ACT_NUM_SET_TAG;
"multiple VLAN actions");
}
}
+ if (action_flags & MLX5_FLOW_ACTION_METER_WITH_TERMINATED_POLICY) {
+ if ((action_flags & (MLX5_FLOW_FATE_ACTIONS &
+ ~MLX5_FLOW_ACTION_METER_WITH_TERMINATED_POLICY)) &&
+ attr->ingress)
+ return rte_flow_error_set
+ (error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, "fate action not supported for "
+ "meter with policy");
+ if (attr->egress) {
+ if (action_flags & MLX5_FLOW_MODIFY_HDR_ACTIONS)
+ return rte_flow_error_set
+ (error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, "modify header action in egress "
+ "cannot be done before meter action");
+ if (action_flags & MLX5_FLOW_ACTION_ENCAP)
+ return rte_flow_error_set
+ (error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, "encap action in egress "
+ "cannot be done before meter action");
+ if (action_flags & MLX5_FLOW_ACTION_OF_PUSH_VLAN)
+ return rte_flow_error_set
+ (error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ACTION,
+ NULL, "push vlan action in egress "
+ "cannot be done before meter action");
+ }
+ }
/*
* Hairpin flow will add one more TAG action in TX implicit mode.
* In TX explicit mode, there will be no hairpin flow ID.
struct mlx5_flow_workspace *wks = mlx5_flow_get_thread_workspace();
MLX5_ASSERT(wks);
+ wks->skip_matcher_reg = 0;
/* In case of corrupting the memory. */
if (wks->flow_idx >= MLX5_NUM_MAX_DEV_FLOWS) {
rte_flow_error_set(error, ENOSPC,
int action_type = actions->type;
const struct rte_flow_action *found_action = NULL;
uint32_t jump_group = 0;
+ struct mlx5_flow_counter *cnt;
if (!mlx5_flow_os_action_supported(action_type))
return rte_flow_error_set(error, ENOTSUP,
age = action->conf;
action_flags |= MLX5_FLOW_ACTION_COUNT;
break;
+ case MLX5_RTE_FLOW_ACTION_TYPE_COUNT:
+ cnt = flow_dv_counter_get_by_idx(dev,
+ (uint32_t)(uintptr_t)action->conf, NULL);
+ MLX5_ASSERT(cnt != NULL);
+ dev_flow->dv.actions[actions_n++] = cnt->action;
+ break;
case RTE_FLOW_ACTION_TYPE_OF_POP_VLAN:
dev_flow->dv.actions[actions_n++] =
priv->sh->pop_vlan_action;
/* If decap is followed by encap, handle it at encap. */
action_flags |= MLX5_FLOW_ACTION_DECAP;
break;
+ case MLX5_RTE_FLOW_ACTION_TYPE_JUMP:
+ dev_flow->dv.actions[actions_n++] =
+ (void *)(uintptr_t)action->conf;
+ action_flags |= MLX5_FLOW_ACTION_JUMP;
+ break;
case RTE_FLOW_ACTION_TYPE_JUMP:
jump_group = ((const struct rte_flow_action_jump *)
action->conf)->group;
}
dev_flow->dv.actions_n = actions_n;
dev_flow->act_flags = action_flags;
+ if (wks->skip_matcher_reg)
+ return 0;
/* Register matcher. */
matcher.crc = rte_raw_cksum((const void *)matcher.mask.buf,
matcher.mask.size);
*
* @param[in] dev
* Pointer to Ethernet device.
- * @param[in] tbl
- * Pointer to the meter table set.
- *
- * @return
- * Always 0.
+ * @param[in] fm
+ * Meter information table.
*/
-static int
-flow_dv_destroy_mtr_tbl(struct rte_eth_dev *dev,
- struct mlx5_meter_domains_infos *tbl)
+static void
+flow_dv_destroy_mtr_tbls(struct rte_eth_dev *dev,
+ struct mlx5_flow_meter_info *fm)
{
struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_meter_domains_infos *mtd =
- (struct mlx5_meter_domains_infos *)tbl;
+ int i;
- if (!mtd || !priv->config.dv_flow_en)
- return 0;
- if (mtd->egress.tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev), mtd->egress.tbl);
- if (mtd->egress.sfx_tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev), mtd->egress.sfx_tbl);
- if (mtd->ingress.tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev), mtd->ingress.tbl);
- if (mtd->ingress.sfx_tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev),
- mtd->ingress.sfx_tbl);
- if (mtd->transfer.tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev), mtd->transfer.tbl);
- if (mtd->transfer.sfx_tbl)
- flow_dv_tbl_resource_release(MLX5_SH(dev),
- mtd->transfer.sfx_tbl);
- mlx5_free(mtd);
- return 0;
+ if (!fm || !priv->config.dv_flow_en)
+ return;
+ for (i = 0; i < MLX5_MTR_DOMAIN_MAX; i++) {
+ if (fm->drop_rule[i]) {
+ claim_zero(mlx5_flow_os_destroy_flow(fm->drop_rule[i]));
+ fm->drop_rule[i] = NULL;
+ }
+ }
}
static void
struct mlx5_priv *priv = dev->data->dev_private;
struct mlx5_flow_mtr_mng *mtrmng = priv->sh->mtrmng;
struct mlx5_flow_tbl_data_entry *tbl;
- int i;
+ int i, j;
for (i = 0; i < MLX5_MTR_DOMAIN_MAX; i++) {
if (mtrmng->def_rule[i]) {
&mtrmng->def_matcher[i]->entry);
mtrmng->def_matcher[i] = NULL;
}
- if (mtrmng->drop_matcher[i]) {
- tbl = container_of(mtrmng->drop_matcher[i]->tbl,
- struct mlx5_flow_tbl_data_entry, tbl);
- mlx5_cache_unregister(&tbl->matchers,
- &mtrmng->drop_matcher[i]->entry);
- mtrmng->drop_matcher[i] = NULL;
+ for (j = 0; j < MLX5_REG_BITS; j++) {
+ if (mtrmng->drop_matcher[i][j]) {
+ tbl =
+ container_of(mtrmng->drop_matcher[i][j]->tbl,
+ struct mlx5_flow_tbl_data_entry,
+ tbl);
+ mlx5_cache_unregister(&tbl->matchers,
+ &mtrmng->drop_matcher[i][j]->entry);
+ mtrmng->drop_matcher[i][j] = NULL;
+ }
}
if (mtrmng->drop_tbl[i]) {
flow_dv_tbl_resource_release(MLX5_SH(dev),
}
/**
- * Create specify domain meter table and suffix table.
+ * Create the needed meter tables.
+ * Lock free, (mutex should be acquired by caller).
*
* @param[in] dev
* Pointer to Ethernet device.
- * @param[in,out] mtb
- * Pointer to DV meter table set.
- * @param[in] egress
- * Table attribute.
- * @param[in] transfer
- * Table attribute.
- *
+ * @param[in] fm
+ * Meter information table.
+ * @param[in] mtr_idx
+ * Meter index.
+ * @param[in] domain_bitmap
+ * Domain bitmap.
* @return
* 0 on success, -1 otherwise.
*/
static int
-flow_dv_prepare_mtr_tables(struct rte_eth_dev *dev,
- struct mlx5_meter_domains_infos *mtb,
- uint8_t egress, uint8_t transfer)
+flow_dv_create_mtr_tbls(struct rte_eth_dev *dev,
+ struct mlx5_flow_meter_info *fm,
+ uint32_t mtr_idx,
+ uint8_t domain_bitmap)
{
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_flow_mtr_mng *mtrmng = priv->sh->mtrmng;
struct rte_flow_error error;
- struct mlx5_meter_domain_info *dtb;
+ struct mlx5_flow_tbl_data_entry *tbl_data;
+ uint8_t egress, transfer;
+ void *actions[METER_ACTIONS];
+ int domain, ret, i;
+ struct mlx5_flow_counter *cnt;
+ struct mlx5_flow_dv_match_params value = {
+ .size = sizeof(value.buf) -
+ MLX5_ST_SZ_BYTES(fte_match_set_misc4),
+ };
+ struct mlx5_flow_dv_match_params matcher_para = {
+ .size = sizeof(matcher_para.buf) -
+ MLX5_ST_SZ_BYTES(fte_match_set_misc4),
+ };
+ int mtr_id_reg_c = mlx5_flow_get_reg_id(dev, MLX5_MTR_ID,
+ 0, &error);
+ uint32_t mtr_id_mask = (UINT32_C(1) << mtrmng->max_mtr_bits) - 1;
+ uint8_t mtr_id_offset = priv->mtr_reg_share ? MLX5_MTR_COLOR_BITS : 0;
+ struct mlx5_cache_entry *entry;
+ struct mlx5_flow_dv_matcher matcher = {
+ .mask = {
+ .size = sizeof(matcher.mask.buf) -
+ MLX5_ST_SZ_BYTES(fte_match_set_misc4),
+ },
+ };
+ struct mlx5_flow_dv_matcher *drop_matcher;
+ struct mlx5_flow_cb_ctx ctx = {
+ .error = &error,
+ .data = &matcher,
+ };
- if (transfer)
- dtb = &mtb->transfer;
- else if (egress)
- dtb = &mtb->egress;
- else
- dtb = &mtb->ingress;
- /* Create the meter suffix table with SUFFIX level. */
- dtb->sfx_tbl = flow_dv_tbl_resource_get(dev,
+ if (!priv->mtr_en || mtr_id_reg_c < 0) {
+ rte_errno = ENOTSUP;
+ return -1;
+ }
+ for (domain = 0; domain < MLX5_MTR_DOMAIN_MAX; domain++) {
+ if (!(domain_bitmap & (1 << domain)) ||
+ (mtrmng->def_rule[domain] && !fm->drop_cnt))
+ continue;
+ egress = (domain == MLX5_MTR_DOMAIN_EGRESS) ? 1 : 0;
+ transfer = (domain == MLX5_MTR_DOMAIN_TRANSFER) ? 1 : 0;
+ /* Create the drop table with METER DROP level. */
+ if (!mtrmng->drop_tbl[domain]) {
+ mtrmng->drop_tbl[domain] = flow_dv_tbl_resource_get(dev,
MLX5_FLOW_TABLE_LEVEL_METER,
egress, transfer, false, NULL, 0,
- 0, MLX5_MTR_TABLE_ID_SUFFIX, &error);
- if (!dtb->sfx_tbl) {
- DRV_LOG(ERR, "Failed to create meter suffix table.");
- return -1;
+ 0, MLX5_MTR_TABLE_ID_DROP, &error);
+ if (!mtrmng->drop_tbl[domain]) {
+ DRV_LOG(ERR, "Failed to create meter drop table.");
+ goto policy_error;
+ }
+ }
+ /* Create default matcher in drop table. */
+ matcher.tbl = mtrmng->drop_tbl[domain],
+ tbl_data = container_of(mtrmng->drop_tbl[domain],
+ struct mlx5_flow_tbl_data_entry, tbl);
+ if (!mtrmng->def_matcher[domain]) {
+ flow_dv_match_meta_reg(matcher.mask.buf, value.buf,
+ (enum modify_reg)mtr_id_reg_c,
+ 0, 0);
+ matcher.priority = MLX5_MTRS_DEFAULT_RULE_PRIORITY;
+ matcher.crc = rte_raw_cksum
+ ((const void *)matcher.mask.buf,
+ matcher.mask.size);
+ entry = mlx5_cache_register(&tbl_data->matchers, &ctx);
+ if (!entry) {
+ DRV_LOG(ERR, "Failed to register meter "
+ "drop default matcher.");
+ goto policy_error;
+ }
+ mtrmng->def_matcher[domain] = container_of(entry,
+ struct mlx5_flow_dv_matcher, entry);
+ }
+ /* Create default rule in drop table. */
+ if (!mtrmng->def_rule[domain]) {
+ i = 0;
+ actions[i++] = priv->sh->dr_drop_action;
+ flow_dv_match_meta_reg(matcher_para.buf, value.buf,
+ (enum modify_reg)mtr_id_reg_c, 0, 0);
+ ret = mlx5_flow_os_create_flow
+ (mtrmng->def_matcher[domain]->matcher_object,
+ (void *)&value, i, actions,
+ &mtrmng->def_rule[domain]);
+ if (ret) {
+ DRV_LOG(ERR, "Failed to create meter "
+ "default drop rule for drop table.");
+ goto policy_error;
+ }
+ }
+ if (!fm->drop_cnt)
+ continue;
+ MLX5_ASSERT(mtrmng->max_mtr_bits);
+ if (!mtrmng->drop_matcher[domain][mtrmng->max_mtr_bits - 1]) {
+ /* Create matchers for Drop. */
+ flow_dv_match_meta_reg(matcher.mask.buf, value.buf,
+ (enum modify_reg)mtr_id_reg_c, 0,
+ (mtr_id_mask << mtr_id_offset));
+ matcher.priority = MLX5_REG_BITS - mtrmng->max_mtr_bits;
+ matcher.crc = rte_raw_cksum
+ ((const void *)matcher.mask.buf,
+ matcher.mask.size);
+ entry = mlx5_cache_register(&tbl_data->matchers, &ctx);
+ if (!entry) {
+ DRV_LOG(ERR,
+ "Failed to register meter drop matcher.");
+ goto policy_error;
+ }
+ mtrmng->drop_matcher[domain][mtrmng->max_mtr_bits - 1] =
+ container_of(entry, struct mlx5_flow_dv_matcher,
+ entry);
+ }
+ drop_matcher =
+ mtrmng->drop_matcher[domain][mtrmng->max_mtr_bits - 1];
+ /* Create drop rule, matching meter_id only. */
+ flow_dv_match_meta_reg(matcher_para.buf, value.buf,
+ (enum modify_reg)mtr_id_reg_c,
+ (mtr_idx << mtr_id_offset), UINT32_MAX);
+ i = 0;
+ cnt = flow_dv_counter_get_by_idx(dev,
+ fm->drop_cnt, NULL);
+ actions[i++] = cnt->action;
+ actions[i++] = priv->sh->dr_drop_action;
+ ret = mlx5_flow_os_create_flow(drop_matcher->matcher_object,
+ (void *)&value, i, actions,
+ &fm->drop_rule[domain]);
+ if (ret) {
+ DRV_LOG(ERR, "Failed to create meter "
+ "drop rule for drop table.");
+ goto policy_error;
+ }
}
return 0;
+policy_error:
+ for (i = 0; i < MLX5_MTR_DOMAIN_MAX; i++) {
+ if (fm->drop_rule[i]) {
+ claim_zero(mlx5_flow_os_destroy_flow
+ (fm->drop_rule[i]));
+ fm->drop_rule[i] = NULL;
+ }
+ }
+ return -1;
}
/**
- * Create the needed meter and suffix tables.
- * Lock free, (mutex should be acquired by caller).
+ * Find the policy table for prefix table with RSS.
*
* @param[in] dev
* Pointer to Ethernet device.
- *
+ * @param[in] mtr_policy
+ * Pointer to meter policy table.
+ * @param[in] rss_desc
+ * Pointer to rss_desc
* @return
* Pointer to table set on success, NULL otherwise and rte_errno is set.
*/
-static struct mlx5_meter_domains_infos *
-flow_dv_create_mtr_tbl(struct rte_eth_dev *dev)
+static struct mlx5_flow_meter_sub_policy *
+flow_dv_meter_sub_policy_rss_prepare(struct rte_eth_dev *dev,
+ struct mlx5_flow_meter_policy *mtr_policy,
+ struct mlx5_flow_rss_desc *rss_desc[MLX5_MTR_RTE_COLORS])
{
struct mlx5_priv *priv = dev->data->dev_private;
- struct mlx5_meter_domains_infos *mtb;
- int ret;
+ struct mlx5_flow_meter_sub_policy *sub_policy = NULL;
+ uint32_t sub_policy_idx = 0;
+ uint32_t hrxq_idx[MLX5_MTR_RTE_COLORS] = {0};
+ uint32_t i, j;
+ struct mlx5_hrxq *hrxq;
+ struct mlx5_flow_handle dh;
+ struct mlx5_meter_policy_action_container *act_cnt;
+ uint32_t domain = MLX5_MTR_DOMAIN_INGRESS;
+ uint16_t sub_policy_num;
- if (!priv->mtr_en) {
- rte_errno = ENOTSUP;
- return NULL;
+ rte_spinlock_lock(&mtr_policy->sl);
+ for (i = 0; i < MLX5_MTR_RTE_COLORS; i++) {
+ if (!rss_desc[i])
+ continue;
+ hrxq_idx[i] = mlx5_hrxq_get(dev, rss_desc[i]);
+ if (!hrxq_idx[i]) {
+ rte_spinlock_unlock(&mtr_policy->sl);
+ return NULL;
+ }
}
- mtb = mlx5_malloc(MLX5_MEM_ZERO, sizeof(*mtb), 0, SOCKET_ID_ANY);
- if (!mtb) {
- DRV_LOG(ERR, "Failed to allocate memory for meter.");
- return NULL;
+ sub_policy_num = (mtr_policy->sub_policy_num >>
+ (MLX5_MTR_SUB_POLICY_NUM_SHIFT * domain)) &
+ MLX5_MTR_SUB_POLICY_NUM_MASK;
+ for (i = 0; i < sub_policy_num;
+ i++) {
+ for (j = 0; j < MLX5_MTR_RTE_COLORS; j++) {
+ if (rss_desc[j] &&
+ hrxq_idx[j] !=
+ mtr_policy->sub_policys[domain][i]->rix_hrxq[j])
+ break;
+ }
+ if (j >= MLX5_MTR_RTE_COLORS) {
+ /*
+ * Found the sub policy table with
+ * the same queue per color
+ */
+ rte_spinlock_unlock(&mtr_policy->sl);
+ for (j = 0; j < MLX5_MTR_RTE_COLORS; j++)
+ mlx5_hrxq_release(dev, hrxq_idx[j]);
+ return mtr_policy->sub_policys[domain][i];
+ }
}
- /* Egress meter table. */
- ret = flow_dv_prepare_mtr_tables(dev, mtb, 1, 0);
- if (ret) {
- DRV_LOG(ERR, "Failed to prepare egress meter table.");
- goto error_exit;
+ /* Create sub policy. */
+ if (!mtr_policy->sub_policys[domain][0]->rix_hrxq[0]) {
+ /* Reuse the first dummy sub_policy*/
+ sub_policy = mtr_policy->sub_policys[domain][0];
+ sub_policy_idx = sub_policy->idx;
+ } else {
+ sub_policy = mlx5_ipool_zmalloc
+ (priv->sh->ipool[MLX5_IPOOL_MTR_POLICY],
+ &sub_policy_idx);
+ if (!sub_policy ||
+ sub_policy_idx > MLX5_MAX_SUB_POLICY_TBL_NUM) {
+ for (i = 0; i < MLX5_MTR_RTE_COLORS; i++)
+ mlx5_hrxq_release(dev, hrxq_idx[i]);
+ goto rss_sub_policy_error;
+ }
+ sub_policy->idx = sub_policy_idx;
+ sub_policy->main_policy = mtr_policy;
}
- /* Ingress meter table. */
- ret = flow_dv_prepare_mtr_tables(dev, mtb, 0, 0);
- if (ret) {
- DRV_LOG(ERR, "Failed to prepare ingress meter table.");
- goto error_exit;
+ for (i = 0; i < MLX5_MTR_RTE_COLORS; i++) {
+ if (!rss_desc[i])
+ continue;
+ sub_policy->rix_hrxq[i] = hrxq_idx[i];
+ /*
+ * Overwrite the last action from
+ * RSS action to Queue action.
+ */
+ hrxq = mlx5_ipool_get(priv->sh->ipool[MLX5_IPOOL_HRXQ],
+ hrxq_idx[i]);
+ if (!hrxq) {
+ DRV_LOG(ERR, "Failed to create policy hrxq");
+ goto rss_sub_policy_error;
+ }
+ act_cnt = &mtr_policy->act_cnt[i];
+ if (act_cnt->rix_mark || act_cnt->modify_hdr) {
+ memset(&dh, 0, sizeof(struct mlx5_flow_handle));
+ if (act_cnt->rix_mark)
+ dh.mark = 1;
+ dh.fate_action = MLX5_FLOW_FATE_QUEUE;
+ dh.rix_hrxq = hrxq_idx[i];
+ flow_drv_rxq_flags_set(dev, &dh);
+ }
}
- /* FDB meter table. */
- if (priv->config.dv_esw_en) {
- ret = flow_dv_prepare_mtr_tables(dev, mtb, 0, 1);
- if (ret) {
- DRV_LOG(ERR, "Failed to prepare fdb meter table.");
- goto error_exit;
+ if (__flow_dv_create_policy_acts_rules(dev, mtr_policy,
+ sub_policy, domain)) {
+ DRV_LOG(ERR, "Failed to create policy "
+ "rules per domain.");
+ goto rss_sub_policy_error;
+ }
+ if (sub_policy != mtr_policy->sub_policys[domain][0]) {
+ i = (mtr_policy->sub_policy_num >>
+ (MLX5_MTR_SUB_POLICY_NUM_SHIFT * domain)) &
+ MLX5_MTR_SUB_POLICY_NUM_MASK;
+ mtr_policy->sub_policys[domain][i] = sub_policy;
+ i++;
+ if (i > MLX5_MTR_RSS_MAX_SUB_POLICY)
+ goto rss_sub_policy_error;
+ mtr_policy->sub_policy_num &= ~(MLX5_MTR_SUB_POLICY_NUM_MASK <<
+ (MLX5_MTR_SUB_POLICY_NUM_SHIFT * domain));
+ mtr_policy->sub_policy_num |=
+ (i & MLX5_MTR_SUB_POLICY_NUM_MASK) <<
+ (MLX5_MTR_SUB_POLICY_NUM_SHIFT * domain);
+ }
+ rte_spinlock_unlock(&mtr_policy->sl);
+ return sub_policy;
+rss_sub_policy_error:
+ if (sub_policy) {
+ __flow_dv_destroy_sub_policy_rules(dev, sub_policy);
+ if (sub_policy != mtr_policy->sub_policys[domain][0]) {
+ i = (mtr_policy->sub_policy_num >>
+ (MLX5_MTR_SUB_POLICY_NUM_SHIFT * domain)) &
+ MLX5_MTR_SUB_POLICY_NUM_MASK;
+ mtr_policy->sub_policys[domain][i] = NULL;
+ mlx5_ipool_free
+ (priv->sh->ipool[MLX5_IPOOL_MTR_POLICY],
+ sub_policy->idx);
}
}
- return mtb;
-error_exit:
- flow_dv_destroy_mtr_tbl(dev, mtb);
+ if (sub_policy_idx)
+ mlx5_ipool_free(priv->sh->ipool[MLX5_IPOOL_MTR_POLICY],
+ sub_policy_idx);
+ rte_spinlock_unlock(&mtr_policy->sl);
return NULL;
}
.remove = flow_dv_remove,
.destroy = flow_dv_destroy,
.query = flow_dv_query,
- .create_mtr_tbls = flow_dv_create_mtr_tbl,
- .destroy_mtr_tbls = flow_dv_destroy_mtr_tbl,
+ .create_mtr_tbls = flow_dv_create_mtr_tbls,
+ .destroy_mtr_tbls = flow_dv_destroy_mtr_tbls,
.destroy_mtr_drop_tbls = flow_dv_destroy_mtr_drop_tbls,
.create_meter = flow_dv_mtr_alloc,
.free_meter = flow_dv_aso_mtr_release_to_pool,
.destroy_policy_rules = flow_dv_destroy_policy_rules,
.create_def_policy = flow_dv_create_def_policy,
.destroy_def_policy = flow_dv_destroy_def_policy,
+ .meter_sub_policy_rss_prepare = flow_dv_meter_sub_policy_rss_prepare,
.counter_alloc = flow_dv_counter_allocate,
.counter_free = flow_dv_counter_free,
.counter_query = flow_dv_counter_query,
git.droids-corp.org / dpdk.git / blobdiff