X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fenic%2Fenic_fm_flow.c;h=c87d3af8476cc3e663d444e3ddc90a86d0a80dc8;hb=66689dc09f0cf92af03abcba58b7474fa8ac847e;hp=ae43f36bc0c5c4b240a2c6a44bc240f6576963cc;hpb=db79f2d5c9f7366004a843e4c65415ac5e1c42a7;p=dpdk.git diff --git a/drivers/net/enic/enic_fm_flow.c b/drivers/net/enic/enic_fm_flow.c index ae43f36bc0..c87d3af847 100644 --- a/drivers/net/enic/enic_fm_flow.c +++ b/drivers/net/enic/enic_fm_flow.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -205,6 +206,7 @@ struct copy_item_args { const struct rte_flow_item *item; struct fm_tcam_match_entry *fm_tcam_entry; uint8_t header_level; + struct rte_flow_error *error; }; /* functions for copying items into flowman match */ @@ -233,6 +235,9 @@ static enic_copy_item_fn enic_fm_copy_item_udp; static enic_copy_item_fn enic_fm_copy_item_vlan; static enic_copy_item_fn enic_fm_copy_item_vxlan; static enic_copy_item_fn enic_fm_copy_item_gtp; +static enic_copy_item_fn enic_fm_copy_item_geneve; +static enic_copy_item_fn enic_fm_copy_item_geneve_opt; +static enic_copy_item_fn enic_fm_copy_item_ecpri; /* Ingress actions */ static const enum rte_flow_action_type enic_fm_supported_ig_actions[] = { @@ -368,6 +373,35 @@ static const struct enic_fm_items enic_fm_items[] = { RTE_FLOW_ITEM_TYPE_END, }, }, + [RTE_FLOW_ITEM_TYPE_GENEVE] = { + .copy_item = enic_fm_copy_item_geneve, + .valid_start_item = 1, + .prev_items = (const enum rte_flow_item_type[]) { + RTE_FLOW_ITEM_TYPE_ETH, + RTE_FLOW_ITEM_TYPE_IPV4, + RTE_FLOW_ITEM_TYPE_IPV6, + RTE_FLOW_ITEM_TYPE_UDP, + RTE_FLOW_ITEM_TYPE_END, + }, + }, + [RTE_FLOW_ITEM_TYPE_GENEVE_OPT] = { + .copy_item = enic_fm_copy_item_geneve_opt, + .valid_start_item = 1, + /* Can match at most 1 option */ + .prev_items = (const enum rte_flow_item_type[]) { + RTE_FLOW_ITEM_TYPE_GENEVE, + RTE_FLOW_ITEM_TYPE_END, + }, + }, + [RTE_FLOW_ITEM_TYPE_ECPRI] = { + .copy_item = enic_fm_copy_item_ecpri, + .valid_start_item = 1, + .prev_items = (const enum rte_flow_item_type[]) { + RTE_FLOW_ITEM_TYPE_ETH, + RTE_FLOW_ITEM_TYPE_UDP, + RTE_FLOW_ITEM_TYPE_END, + }, + }, }; static int @@ -721,7 +755,7 @@ enic_fm_copy_item_gtp(struct copy_item_args *arg) } /* NIC does not support GTP tunnels. No Items are allowed after this. - * This prevents the specificaiton of further items. + * This prevents the specification of further items. */ arg->header_level = 0; @@ -733,7 +767,7 @@ enic_fm_copy_item_gtp(struct copy_item_args *arg) /* * Use the raw L4 buffer to match GTP as fm_header_set does not have - * GTP header. UDP dst port must be specifiec. Using the raw buffer + * GTP header. UDP dst port must be specific. Using the raw buffer * does not affect such UDP item, since we skip UDP in the raw buffer. */ fm_data->fk_header_select |= FKH_L4RAW; @@ -744,6 +778,170 @@ enic_fm_copy_item_gtp(struct copy_item_args *arg) return 0; } +static int +enic_fm_copy_item_geneve(struct copy_item_args *arg) +{ + const struct rte_flow_item *item = arg->item; + const struct rte_flow_item_geneve *spec = item->spec; + const struct rte_flow_item_geneve *mask = item->mask; + struct fm_tcam_match_entry *entry = arg->fm_tcam_entry; + struct fm_header_set *fm_data, *fm_mask; + int off; + + ENICPMD_FUNC_TRACE(); + /* Only 2 header levels (outer and inner) allowed */ + if (arg->header_level > 0) + return -EINVAL; + + fm_data = &entry->ftm_data.fk_hdrset[0]; + fm_mask = &entry->ftm_mask.fk_hdrset[0]; + fm_data->fk_metadata |= FKM_GENEVE; + fm_mask->fk_metadata |= FKM_GENEVE; + /* items from here on out are inner header items, except options */ + arg->header_level = 1; + + /* Match all if no spec */ + if (!spec) + return 0; + if (!mask) + mask = &rte_flow_item_geneve_mask; + + /* + * Use the raw L4 buffer to match geneve as fm_header_set does + * not have geneve header. A UDP item may precede the geneve + * item. Using the raw buffer does not affect such UDP item, + * since we skip UDP in the raw buffer. + */ + fm_data->fk_header_select |= FKH_L4RAW; + fm_mask->fk_header_select |= FKH_L4RAW; + off = sizeof(fm_data->l4.udp); + memcpy(&fm_data->l4.rawdata[off], spec, sizeof(struct rte_geneve_hdr)); + memcpy(&fm_mask->l4.rawdata[off], mask, sizeof(struct rte_geneve_hdr)); + return 0; +} + +static int +enic_fm_copy_item_geneve_opt(struct copy_item_args *arg) +{ + const struct rte_flow_item *item = arg->item; + const struct rte_flow_item_geneve_opt *spec = item->spec; + const struct rte_flow_item_geneve_opt *mask = item->mask; + struct fm_tcam_match_entry *entry = arg->fm_tcam_entry; + struct fm_header_set *fm_data, *fm_mask; + struct rte_geneve_hdr *geneve; + int off, len; + + ENICPMD_FUNC_TRACE(); + fm_data = &entry->ftm_data.fk_hdrset[0]; + fm_mask = &entry->ftm_mask.fk_hdrset[0]; + /* Match all if no spec */ + if (!spec) + return 0; + if (!mask) + mask = &rte_flow_item_geneve_opt_mask; + + if (spec->option_len > 0 && + (spec->data == NULL || mask->data == NULL)) { + return rte_flow_error_set(arg->error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + NULL, "enic: geneve_opt unexpected null data"); + } + /* + * Geneve item must already be in the raw buffer. Append the + * option pattern to it. There are two limitations. + * (1) Can match only the 1st option, the first one following Geneve + * (2) Geneve header must specify option length, as HW does not + * have "has Geneve option" flag. + */ + RTE_ASSERT((fm_data->fk_header_select & FKH_L4RAW) != 0); + RTE_ASSERT((fm_mask->fk_header_select & FKH_L4RAW) != 0); + off = sizeof(fm_data->l4.udp); + geneve = (struct rte_geneve_hdr *)&fm_data->l4.rawdata[off]; + if (geneve->opt_len == 0) { + return rte_flow_error_set(arg->error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + NULL, "enic: geneve_opt requires non-zero geneve option length"); + } + geneve = (struct rte_geneve_hdr *)&fm_mask->l4.rawdata[off]; + if (geneve->opt_len == 0) { + return rte_flow_error_set(arg->error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + NULL, "enic: geneve_opt requires non-zero geneve option length mask"); + } + off = sizeof(fm_data->l4.udp) + sizeof(struct rte_geneve_hdr); + if (off + (spec->option_len + 1) * 4 > FM_LAYER_SIZE) { + return rte_flow_error_set(arg->error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + NULL, "enic: geneve_opt too large"); + } + /* Copy option header */ + memcpy(&fm_data->l4.rawdata[off], spec, 4); + memcpy(&fm_mask->l4.rawdata[off], mask, 4); + /* Copy option data */ + if (spec->option_len > 0) { + off += 4; + len = spec->option_len * 4; + memcpy(&fm_data->l4.rawdata[off], spec->data, len); + memcpy(&fm_mask->l4.rawdata[off], mask->data, len); + } + return 0; +} + +/* Match eCPRI combined message header */ +static int +enic_fm_copy_item_ecpri(struct copy_item_args *arg) +{ + const struct rte_flow_item *item = arg->item; + const struct rte_flow_item_ecpri *spec = item->spec; + const struct rte_flow_item_ecpri *mask = item->mask; + struct fm_tcam_match_entry *entry = arg->fm_tcam_entry; + struct fm_header_set *fm_data, *fm_mask; + uint8_t *fm_data_to, *fm_mask_to; + + ENICPMD_FUNC_TRACE(); + + /* Tunneling not supported- only matching on inner eCPRI fields. */ + if (arg->header_level > 0) + return -EINVAL; + + /* Need both spec and mask */ + if (!spec || !mask) + return -EINVAL; + + fm_data = &entry->ftm_data.fk_hdrset[0]; + fm_mask = &entry->ftm_mask.fk_hdrset[0]; + + /* eCPRI can only follow L2/VLAN layer if ethernet type is 0xAEFE. */ + if (!(fm_data->fk_metadata & FKM_UDP) && + (fm_mask->l2.eth.fk_ethtype != UINT16_MAX || + rte_cpu_to_be_16(fm_data->l2.eth.fk_ethtype) != + RTE_ETHER_TYPE_ECPRI)) + return -EINVAL; + + if (fm_data->fk_metadata & FKM_UDP) { + /* eCPRI on UDP */ + fm_data->fk_header_select |= FKH_L4RAW; + fm_mask->fk_header_select |= FKH_L4RAW; + fm_data_to = &fm_data->l4.rawdata[sizeof(fm_data->l4.udp)]; + fm_mask_to = &fm_mask->l4.rawdata[sizeof(fm_data->l4.udp)]; + } else { + /* eCPRI directly after Etherent header */ + fm_data->fk_header_select |= FKH_L3RAW; + fm_mask->fk_header_select |= FKH_L3RAW; + fm_data_to = &fm_data->l3.rawdata[0]; + fm_mask_to = &fm_mask->l3.rawdata[0]; + } + + /* + * Use the raw L3 or L4 buffer to match eCPRI since fm_header_set does + * not have eCPRI header. Only 1st message header of PDU can be matched. + * "C" * bit ignored. + */ + memcpy(fm_data_to, spec, sizeof(*spec)); + memcpy(fm_mask_to, mask, sizeof(*mask)); + return 0; +} + /* * Currently, raw pattern match is very limited. It is intended for matching * UDP tunnel header (e.g. vxlan or geneve). @@ -984,16 +1182,32 @@ enic_fm_copy_entry(struct enic_flowman *fm, RTE_FLOW_ERROR_TYPE_ITEM, NULL, "enic: unsupported item"); } - + /* + * Check vNIC feature dependencies. Geneve item needs + * Geneve offload feature + */ + if (item->type == RTE_FLOW_ITEM_TYPE_GENEVE && + !fm->user_enic->geneve) { + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ITEM, + NULL, "enic: geneve not supported"); + } /* check to see if item stacking is valid */ if (!fm_item_stacking_valid(prev_item, item_info, is_first_item)) goto stacking_error; args.item = item; + args.error = error; + if (error) + error->type = RTE_FLOW_ERROR_TYPE_NONE; ret = item_info->copy_item(&args); - if (ret) + if (ret) { + /* If copy_item set the error, return that */ + if (error && error->type != RTE_FLOW_ERROR_TYPE_NONE) + return ret; goto item_not_supported; + } /* Going from outer to inner? Treat it as a new packet start */ if (prev_header_level != args.header_level) { prev_item = RTE_FLOW_ITEM_TYPE_END; @@ -1846,7 +2060,7 @@ enic_fm_dump_tcam_actions(const struct fm_action *fm_action) /* Remove trailing comma */ if (buf[0]) *(bp - 1) = '\0'; - ENICPMD_LOG(DEBUG, " Acions: %s", buf); + ENICPMD_LOG(DEBUG, " Actions: %s", buf); } static int @@ -2364,7 +2578,7 @@ enic_action_handle_get(struct enic_flowman *fm, struct fm_action *action_in, if (ret < 0 && ret != -ENOENT) return rte_flow_error_set(error, -ret, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, - NULL, "enic: rte_hash_lookup(aciton)"); + NULL, "enic: rte_hash_lookup(action)"); if (ret == -ENOENT) { /* Allocate a new action on the NIC. */ @@ -2372,11 +2586,11 @@ enic_action_handle_get(struct enic_flowman *fm, struct fm_action *action_in, memcpy(fma, action_in, sizeof(*fma)); ah = calloc(1, sizeof(*ah)); - memcpy(&ah->key, action_in, sizeof(struct fm_action)); if (ah == NULL) return rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE, NULL, "enic: calloc(fm-action)"); + memcpy(&ah->key, action_in, sizeof(struct fm_action)); args[0] = FM_ACTION_ALLOC; args[1] = fm->cmd.pa; ret = flowman_cmd(fm, args, 2); @@ -2435,7 +2649,7 @@ __enic_fm_flow_add_entry(struct enic_flowman *fm, ENICPMD_FUNC_TRACE(); - /* Get or create an aciton handle. */ + /* Get or create an action handle. */ ret = enic_action_handle_get(fm, action_in, error, &ah); if (ret) return ret;