X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fhns3%2Fhns3_flow.c;h=86ebbf69b645ab61d45be880445142df30eefef5;hb=56f8be38712d839135bde690dae4239e21b2ca73;hp=00084872ad2a87faf44f772f45eaed8875515e9a;hpb=67d0b17947d6936147f4cbfff6ff938884f14776;p=dpdk.git diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c index 00084872ad..86ebbf69b6 100644 --- a/drivers/net/hns3/hns3_flow.c +++ b/drivers/net/hns3/hns3_flow.c @@ -154,7 +154,7 @@ hns3_counter_lookup(struct rte_eth_dev *dev, uint32_t id) } static int -hns3_counter_new(struct rte_eth_dev *dev, uint32_t shared, uint32_t id, +hns3_counter_new(struct rte_eth_dev *dev, uint32_t indirect, uint32_t id, struct rte_flow_error *error) { struct hns3_adapter *hns = dev->data->dev_private; @@ -166,11 +166,14 @@ hns3_counter_new(struct rte_eth_dev *dev, uint32_t shared, uint32_t id, cnt = hns3_counter_lookup(dev, id); if (cnt) { - if (!cnt->shared || cnt->shared != shared) + if (!cnt->indirect || cnt->indirect != indirect) return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION_CONF, cnt, - "Counter id is used, shared flag not match"); + "Counter id is used, indirect flag not match"); + /* Clear the indirect counter on first use. */ + if (cnt->indirect && cnt->ref_cnt == 1) + (void)hns3_get_count(hw, id, &value); cnt->ref_cnt++; return 0; } @@ -188,7 +191,7 @@ hns3_counter_new(struct rte_eth_dev *dev, uint32_t shared, uint32_t id, RTE_FLOW_ERROR_TYPE_HANDLE, cnt, "Alloc mem for counter failed"); cnt->id = id; - cnt->shared = shared; + cnt->indirect = indirect; cnt->ref_cnt = 1; cnt->hits = 0; LIST_INSERT_HEAD(&pf->flow_counters, cnt, next); @@ -253,16 +256,30 @@ hns3_counter_release(struct rte_eth_dev *dev, uint32_t id) static void hns3_counter_flush(struct rte_eth_dev *dev) { - struct hns3_adapter *hns = dev->data->dev_private; - struct hns3_pf *pf = &hns->pf; + struct hns3_pf *pf = HNS3_DEV_PRIVATE_TO_PF(dev->data->dev_private); + LIST_HEAD(counters, hns3_flow_counter) indir_counters; struct hns3_flow_counter *cnt_ptr; + LIST_INIT(&indir_counters); cnt_ptr = LIST_FIRST(&pf->flow_counters); while (cnt_ptr) { LIST_REMOVE(cnt_ptr, next); - rte_free(cnt_ptr); + if (cnt_ptr->indirect) + LIST_INSERT_HEAD(&indir_counters, cnt_ptr, next); + else + rte_free(cnt_ptr); cnt_ptr = LIST_FIRST(&pf->flow_counters); } + + /* Reset the indirect action and add to pf->flow_counters list. */ + cnt_ptr = LIST_FIRST(&indir_counters); + while (cnt_ptr) { + LIST_REMOVE(cnt_ptr, next); + cnt_ptr->ref_cnt = 1; + cnt_ptr->hits = 0; + LIST_INSERT_HEAD(&pf->flow_counters, cnt_ptr, next); + cnt_ptr = LIST_FIRST(&indir_counters); + } } static int @@ -332,6 +349,30 @@ hns3_handle_action_queue_region(struct rte_eth_dev *dev, return 0; } +static int +hns3_handle_action_indirect(struct rte_eth_dev *dev, + const struct rte_flow_action *action, + struct hns3_fdir_rule *rule, + struct rte_flow_error *error) +{ + const struct rte_flow_action_handle *indir = action->conf; + + if (indir->indirect_type != HNS3_INDIRECT_ACTION_TYPE_COUNT) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + action, "Invalid indirect type"); + + if (hns3_counter_lookup(dev, indir->counter_id) == NULL) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + action, "Counter id not exist"); + + rule->act_cnt.id = indir->counter_id; + rule->flags |= (HNS3_RULE_FLAG_COUNTER | HNS3_RULE_FLAG_COUNTER_INDIR); + + return 0; +} + /* * Parse actions structure from the provided pattern. * The pattern is validated as the items are copied. @@ -403,6 +444,13 @@ hns3_handle_actions(struct rte_eth_dev *dev, "Invalid counter id"); rule->act_cnt = *act_count; rule->flags |= HNS3_RULE_FLAG_COUNTER; + rule->flags &= ~HNS3_RULE_FLAG_COUNTER_INDIR; + break; + case RTE_FLOW_ACTION_TYPE_INDIRECT: + ret = hns3_handle_action_indirect(dev, actions, rule, + error); + if (ret) + return ret; break; case RTE_FLOW_ACTION_TYPE_VOID: break; @@ -1238,6 +1286,7 @@ static bool hns3_action_rss_same(const struct rte_flow_action_rss *comp, const struct rte_flow_action_rss *with) { + bool rss_key_is_same; bool func_is_same; /* @@ -1254,11 +1303,16 @@ hns3_action_rss_same(const struct rte_flow_action_rss *comp, func_is_same = (with->func != RTE_ETH_HASH_FUNCTION_DEFAULT) ? (comp->func == with->func) : true; - return (func_is_same && + if (with->key_len == 0 || with->key == NULL) + rss_key_is_same = 1; + else + rss_key_is_same = comp->key_len == with->key_len && + !memcmp(comp->key, with->key, with->key_len); + + return (func_is_same && rss_key_is_same && comp->types == (with->types & HNS3_ETH_RSS_SUPPORT) && - comp->level == with->level && comp->key_len == with->key_len && + comp->level == with->level && comp->queue_num == with->queue_num && - !memcmp(comp->key, with->key, with->key_len) && !memcmp(comp->queue, with->queue, sizeof(*with->queue) * with->queue_num)); } @@ -1392,20 +1446,15 @@ hns3_disable_rss(struct hns3_hw *hw) { int ret; - /* Redirected the redirection table to queue 0 */ - ret = hns3_rss_reset_indir_table(hw); + ret = hns3_set_rss_tuple_by_rss_hf(hw, 0); if (ret) return ret; - /* Disable RSS */ - hw->rss_info.conf.types = 0; - hw->rss_dis_flag = true; - return 0; } static void -hns3_parse_rss_key(struct hns3_hw *hw, struct rte_flow_action_rss *rss_conf) +hns3_adjust_rss_key(struct hns3_hw *hw, struct rte_flow_action_rss *rss_conf) { if (rss_conf->key == NULL || rss_conf->key_len < HNS3_RSS_KEY_SIZE) { hns3_warn(hw, "Default RSS hash key to be set"); @@ -1446,10 +1495,9 @@ hns3_parse_rss_algorithm(struct hns3_hw *hw, enum rte_eth_hash_function *func, static int hns3_hw_rss_hash_set(struct hns3_hw *hw, struct rte_flow_action_rss *rss_config) { - struct hns3_rss_tuple_cfg *tuple; int ret; - hns3_parse_rss_key(hw, rss_config); + hns3_adjust_rss_key(hw, rss_config); ret = hns3_parse_rss_algorithm(hw, &rss_config->func, &hw->rss_info.hash_algo); @@ -1462,8 +1510,7 @@ hns3_hw_rss_hash_set(struct hns3_hw *hw, struct rte_flow_action_rss *rss_config) hw->rss_info.conf.func = rss_config->func; - tuple = &hw->rss_info.rss_tuple_sets; - ret = hns3_set_rss_tuple_by_rss_hf(hw, tuple, rss_config->types); + ret = hns3_set_rss_tuple_by_rss_hf(hw, rss_config->types); if (ret) hns3_err(hw, "Update RSS tuples by rss hf failed %d", ret); @@ -1706,6 +1753,107 @@ hns3_flow_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, return hns3_parse_fdir_filter(dev, pattern, actions, &fdir_rule, error); } +static int +hns3_flow_create_rss_rule(struct rte_eth_dev *dev, + const struct rte_flow_action *act, + struct rte_flow *flow) +{ + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_rss_conf_ele *rss_filter_ptr; + const struct hns3_rss_conf *rss_conf; + int ret; + + rss_filter_ptr = rte_zmalloc("hns3 rss filter", + sizeof(struct hns3_rss_conf_ele), 0); + if (rss_filter_ptr == NULL) { + hns3_err(hw, "failed to allocate hns3_rss_filter memory"); + return -ENOMEM; + } + + /* + * After all the preceding tasks are successfully configured, configure + * rules to the hardware to simplify the rollback of rules in the + * hardware. + */ + rss_conf = (const struct hns3_rss_conf *)act->conf; + ret = hns3_flow_parse_rss(dev, rss_conf, true); + if (ret != 0) { + rte_free(rss_filter_ptr); + return ret; + } + + hns3_rss_conf_copy(&rss_filter_ptr->filter_info, &rss_conf->conf); + rss_filter_ptr->filter_info.valid = true; + TAILQ_INSERT_TAIL(&hw->flow_rss_list, rss_filter_ptr, entries); + flow->rule = rss_filter_ptr; + flow->filter_type = RTE_ETH_FILTER_HASH; + + return 0; +} + +static int +hns3_flow_create_fdir_rule(struct rte_eth_dev *dev, + const struct rte_flow_item pattern[], + const struct rte_flow_action actions[], + struct rte_flow_error *error, + struct rte_flow *flow) +{ + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + struct hns3_fdir_rule_ele *fdir_rule_ptr; + struct hns3_fdir_rule fdir_rule; + bool indir; + int ret; + + memset(&fdir_rule, 0, sizeof(struct hns3_fdir_rule)); + ret = hns3_parse_fdir_filter(dev, pattern, actions, &fdir_rule, error); + if (ret != 0) + return ret; + + indir = !!(fdir_rule.flags & HNS3_RULE_FLAG_COUNTER_INDIR); + if (fdir_rule.flags & HNS3_RULE_FLAG_COUNTER) { + ret = hns3_counter_new(dev, indir, fdir_rule.act_cnt.id, + error); + if (ret != 0) + return ret; + + flow->counter_id = fdir_rule.act_cnt.id; + } + + fdir_rule_ptr = rte_zmalloc("hns3 fdir rule", + sizeof(struct hns3_fdir_rule_ele), 0); + if (fdir_rule_ptr == NULL) { + hns3_err(hw, "failed to allocate fdir_rule memory."); + ret = -ENOMEM; + goto err_malloc; + } + + /* + * After all the preceding tasks are successfully configured, configure + * rules to the hardware to simplify the rollback of rules in the + * hardware. + */ + ret = hns3_fdir_filter_program(hns, &fdir_rule, false); + if (ret != 0) + goto err_fdir_filter; + + memcpy(&fdir_rule_ptr->fdir_conf, &fdir_rule, + sizeof(struct hns3_fdir_rule)); + TAILQ_INSERT_TAIL(&hw->flow_fdir_list, fdir_rule_ptr, entries); + flow->rule = fdir_rule_ptr; + flow->filter_type = RTE_ETH_FILTER_FDIR; + + return 0; + +err_fdir_filter: + rte_free(fdir_rule_ptr); +err_malloc: + if (fdir_rule.flags & HNS3_RULE_FLAG_COUNTER) + hns3_counter_release(dev, fdir_rule.act_cnt.id); + + return ret; +} + /* * Create or destroy a flow rule. * Theorically one rule can match more than one filters. @@ -1720,13 +1868,9 @@ hns3_flow_create(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, { struct hns3_adapter *hns = dev->data->dev_private; struct hns3_hw *hw = &hns->hw; - const struct hns3_rss_conf *rss_conf; - struct hns3_fdir_rule_ele *fdir_rule_ptr; - struct hns3_rss_conf_ele *rss_filter_ptr; struct hns3_flow_mem *flow_node; const struct rte_flow_action *act; struct rte_flow *flow; - struct hns3_fdir_rule fdir_rule; int ret; ret = hns3_flow_validate(dev, attr, pattern, actions, error); @@ -1752,76 +1896,20 @@ hns3_flow_create(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, TAILQ_INSERT_TAIL(&hw->flow_list, flow_node, entries); act = hns3_find_rss_general_action(pattern, actions); - if (act) { - rss_conf = act->conf; - - ret = hns3_flow_parse_rss(dev, rss_conf, true); - if (ret) - goto err; - - rss_filter_ptr = rte_zmalloc("hns3 rss filter", - sizeof(struct hns3_rss_conf_ele), - 0); - if (rss_filter_ptr == NULL) { - hns3_err(hw, - "Failed to allocate hns3_rss_filter memory"); - ret = -ENOMEM; - goto err; - } - hns3_rss_conf_copy(&rss_filter_ptr->filter_info, - &rss_conf->conf); - rss_filter_ptr->filter_info.valid = true; - TAILQ_INSERT_TAIL(&hw->flow_rss_list, rss_filter_ptr, entries); - - flow->rule = rss_filter_ptr; - flow->filter_type = RTE_ETH_FILTER_HASH; - return flow; - } - - memset(&fdir_rule, 0, sizeof(struct hns3_fdir_rule)); - ret = hns3_parse_fdir_filter(dev, pattern, actions, &fdir_rule, error); - if (ret) - goto out; - - if (fdir_rule.flags & HNS3_RULE_FLAG_COUNTER) { - ret = hns3_counter_new(dev, 0, fdir_rule.act_cnt.id, error); - if (ret) - goto out; - - flow->counter_id = fdir_rule.act_cnt.id; - } - - fdir_rule_ptr = rte_zmalloc("hns3 fdir rule", - sizeof(struct hns3_fdir_rule_ele), - 0); - if (fdir_rule_ptr == NULL) { - hns3_err(hw, "failed to allocate fdir_rule memory."); - ret = -ENOMEM; - goto err_fdir; - } - - ret = hns3_fdir_filter_program(hns, &fdir_rule, false); - if (!ret) { - memcpy(&fdir_rule_ptr->fdir_conf, &fdir_rule, - sizeof(struct hns3_fdir_rule)); - TAILQ_INSERT_TAIL(&hw->flow_fdir_list, fdir_rule_ptr, entries); - flow->rule = fdir_rule_ptr; - flow->filter_type = RTE_ETH_FILTER_FDIR; - + if (act) + ret = hns3_flow_create_rss_rule(dev, act, flow); + else + ret = hns3_flow_create_fdir_rule(dev, pattern, actions, + error, flow); + if (ret == 0) return flow; - } - rte_free(fdir_rule_ptr); -err_fdir: - if (fdir_rule.flags & HNS3_RULE_FLAG_COUNTER) - hns3_counter_release(dev, fdir_rule.act_cnt.id); -err: rte_flow_error_set(error, -ret, RTE_FLOW_ERROR_TYPE_HANDLE, NULL, "Failed to create flow"); -out: TAILQ_REMOVE(&hw->flow_list, flow_node, entries); rte_free(flow_node); rte_free(flow); + return NULL; } @@ -2047,6 +2135,157 @@ hns3_flow_query_wrap(struct rte_eth_dev *dev, struct rte_flow *flow, return ret; } +static int +hns3_check_indir_action(const struct rte_flow_indir_action_conf *conf, + const struct rte_flow_action *action, + struct rte_flow_error *error) +{ + if (!conf->ingress) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "Indir action ingress can't be zero"); + + if (conf->egress) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "Indir action not support egress"); + + if (conf->transfer) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "Indir action not support transfer"); + + if (action->type != RTE_FLOW_ACTION_TYPE_COUNT) + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + NULL, "Indir action only support count"); + + return 0; +} + +static struct rte_flow_action_handle * +hns3_flow_action_create(struct rte_eth_dev *dev, + const struct rte_flow_indir_action_conf *conf, + const struct rte_flow_action *action, + struct rte_flow_error *error) +{ + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_pf *pf = HNS3_DEV_PRIVATE_TO_PF(dev->data->dev_private); + const struct rte_flow_action_count *act_count; + struct rte_flow_action_handle *handle = NULL; + struct hns3_flow_counter *counter; + + if (hns3_check_indir_action(conf, action, error)) + return NULL; + + handle = rte_zmalloc("hns3 action handle", + sizeof(struct rte_flow_action_handle), 0); + if (handle == NULL) { + rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE, + NULL, "Failed to allocate action memory"); + return NULL; + } + + pthread_mutex_lock(&hw->flows_lock); + + act_count = (const struct rte_flow_action_count *)action->conf; + if (act_count->id >= pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_1]) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + action, "Invalid counter id"); + goto err_exit; + } + + if (hns3_counter_new(dev, false, act_count->id, error)) + goto err_exit; + + counter = hns3_counter_lookup(dev, act_count->id); + if (counter == NULL) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + action, "Counter id not found"); + goto err_exit; + } + + counter->indirect = true; + handle->indirect_type = HNS3_INDIRECT_ACTION_TYPE_COUNT; + handle->counter_id = counter->id; + + pthread_mutex_unlock(&hw->flows_lock); + return handle; + +err_exit: + pthread_mutex_unlock(&hw->flows_lock); + rte_free(handle); + return NULL; +} + +static int +hns3_flow_action_destroy(struct rte_eth_dev *dev, + struct rte_flow_action_handle *handle, + struct rte_flow_error *error) +{ + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_flow_counter *counter; + + pthread_mutex_lock(&hw->flows_lock); + + if (handle->indirect_type != HNS3_INDIRECT_ACTION_TYPE_COUNT) { + pthread_mutex_unlock(&hw->flows_lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Invalid indirect type"); + } + + counter = hns3_counter_lookup(dev, handle->counter_id); + if (counter == NULL) { + pthread_mutex_unlock(&hw->flows_lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Counter id not exist"); + } + + if (counter->ref_cnt > 1) { + pthread_mutex_unlock(&hw->flows_lock); + return rte_flow_error_set(error, EBUSY, + RTE_FLOW_ERROR_TYPE_HANDLE, + handle, "Counter id in use"); + } + + (void)hns3_counter_release(dev, handle->counter_id); + rte_free(handle); + + pthread_mutex_unlock(&hw->flows_lock); + return 0; +} + +static int +hns3_flow_action_query(struct rte_eth_dev *dev, + const struct rte_flow_action_handle *handle, + void *data, + struct rte_flow_error *error) +{ + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct rte_flow flow; + int ret; + + pthread_mutex_lock(&hw->flows_lock); + + if (handle->indirect_type != HNS3_INDIRECT_ACTION_TYPE_COUNT) { + pthread_mutex_unlock(&hw->flows_lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Invalid indirect type"); + } + + memset(&flow, 0, sizeof(flow)); + flow.counter_id = handle->counter_id; + ret = hns3_counter_query(dev, &flow, + (struct rte_flow_query_count *)data, error); + pthread_mutex_unlock(&hw->flows_lock); + return ret; +} + static const struct rte_flow_ops hns3_flow_ops = { .validate = hns3_flow_validate_wrap, .create = hns3_flow_create_wrap, @@ -2054,6 +2293,9 @@ static const struct rte_flow_ops hns3_flow_ops = { .flush = hns3_flow_flush_wrap, .query = hns3_flow_query_wrap, .isolate = NULL, + .action_handle_create = hns3_flow_action_create, + .action_handle_destroy = hns3_flow_action_destroy, + .action_handle_query = hns3_flow_action_query, }; int