X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_ethdev%2Frte_flow.c;h=d3e5cbc194f6f90bd68775c891cadfe2f3f5654b;hb=d992fa555d23bb77079acd184ab60011277324d0;hp=4fd6cfa7689c0a4b05109f19bb26f3540d40cdae;hpb=063911ee1df4950bc6af387b89ee9fdb39aa0650;p=dpdk.git diff --git a/lib/librte_ethdev/rte_flow.c b/lib/librte_ethdev/rte_flow.c index 4fd6cfa768..d3e5cbc194 100644 --- a/lib/librte_ethdev/rte_flow.c +++ b/lib/librte_ethdev/rte_flow.c @@ -11,10 +11,19 @@ #include #include #include +#include +#include +#include #include "rte_ethdev.h" #include "rte_flow_driver.h" #include "rte_flow.h" +/* Mbuf dynamic field name for metadata. */ +int32_t rte_flow_dynf_metadata_offs = -1; + +/* Mbuf dynamic field flag bit number for metadata. */ +uint64_t rte_flow_dynf_metadata_mask; + /** * Flow elements description tables. */ @@ -50,14 +59,20 @@ static const struct rte_flow_desc_data rte_flow_desc_item[] = { MK_FLOW_ITEM(TCP, sizeof(struct rte_flow_item_tcp)), MK_FLOW_ITEM(SCTP, sizeof(struct rte_flow_item_sctp)), MK_FLOW_ITEM(VXLAN, sizeof(struct rte_flow_item_vxlan)), - MK_FLOW_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)), - MK_FLOW_ITEM(GRE, sizeof(struct rte_flow_item_gre)), MK_FLOW_ITEM(E_TAG, sizeof(struct rte_flow_item_e_tag)), MK_FLOW_ITEM(NVGRE, sizeof(struct rte_flow_item_nvgre)), + MK_FLOW_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)), + MK_FLOW_ITEM(GRE, sizeof(struct rte_flow_item_gre)), + MK_FLOW_ITEM(FUZZY, sizeof(struct rte_flow_item_fuzzy)), + MK_FLOW_ITEM(GTP, sizeof(struct rte_flow_item_gtp)), + MK_FLOW_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)), + MK_FLOW_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)), + MK_FLOW_ITEM(ESP, sizeof(struct rte_flow_item_esp)), MK_FLOW_ITEM(GENEVE, sizeof(struct rte_flow_item_geneve)), MK_FLOW_ITEM(VXLAN_GPE, sizeof(struct rte_flow_item_vxlan_gpe)), MK_FLOW_ITEM(ARP_ETH_IPV4, sizeof(struct rte_flow_item_arp_eth_ipv4)), MK_FLOW_ITEM(IPV6_EXT, sizeof(struct rte_flow_item_ipv6_ext)), + MK_FLOW_ITEM(IPV6_FRAG_EXT, sizeof(struct rte_flow_item_ipv6_frag_ext)), MK_FLOW_ITEM(ICMP6, sizeof(struct rte_flow_item_icmp6)), MK_FLOW_ITEM(ICMP6_ND_NS, sizeof(struct rte_flow_item_icmp6_nd_ns)), MK_FLOW_ITEM(ICMP6_ND_NA, sizeof(struct rte_flow_item_icmp6_nd_na)), @@ -66,6 +81,22 @@ static const struct rte_flow_desc_data rte_flow_desc_item[] = { sizeof(struct rte_flow_item_icmp6_nd_opt_sla_eth)), MK_FLOW_ITEM(ICMP6_ND_OPT_TLA_ETH, sizeof(struct rte_flow_item_icmp6_nd_opt_tla_eth)), + MK_FLOW_ITEM(MARK, sizeof(struct rte_flow_item_mark)), + MK_FLOW_ITEM(META, sizeof(struct rte_flow_item_meta)), + MK_FLOW_ITEM(TAG, sizeof(struct rte_flow_item_tag)), + MK_FLOW_ITEM(GRE_KEY, sizeof(rte_be32_t)), + MK_FLOW_ITEM(GTP_PSC, sizeof(struct rte_flow_item_gtp_psc)), + MK_FLOW_ITEM(PPPOES, sizeof(struct rte_flow_item_pppoe)), + MK_FLOW_ITEM(PPPOED, sizeof(struct rte_flow_item_pppoe)), + MK_FLOW_ITEM(PPPOE_PROTO_ID, + sizeof(struct rte_flow_item_pppoe_proto_id)), + MK_FLOW_ITEM(NSH, sizeof(struct rte_flow_item_nsh)), + MK_FLOW_ITEM(IGMP, sizeof(struct rte_flow_item_igmp)), + MK_FLOW_ITEM(AH, sizeof(struct rte_flow_item_ah)), + MK_FLOW_ITEM(HIGIG2, sizeof(struct rte_flow_item_higig2_hdr)), + MK_FLOW_ITEM(L2TPV3OIP, sizeof(struct rte_flow_item_l2tpv3oip)), + MK_FLOW_ITEM(PFCP, sizeof(struct rte_flow_item_pfcp)), + MK_FLOW_ITEM(ECPRI, sizeof(struct rte_flow_item_ecpri)), }; /** Generate flow_action[] entry. */ @@ -80,6 +111,7 @@ static const struct rte_flow_desc_data rte_flow_desc_action[] = { MK_FLOW_ACTION(END, 0), MK_FLOW_ACTION(VOID, 0), MK_FLOW_ACTION(PASSTHRU, 0), + MK_FLOW_ACTION(JUMP, sizeof(struct rte_flow_action_jump)), MK_FLOW_ACTION(MARK, sizeof(struct rte_flow_action_mark)), MK_FLOW_ACTION(FLAG, 0), MK_FLOW_ACTION(QUEUE, sizeof(struct rte_flow_action_queue)), @@ -90,6 +122,8 @@ static const struct rte_flow_desc_data rte_flow_desc_action[] = { MK_FLOW_ACTION(VF, sizeof(struct rte_flow_action_vf)), MK_FLOW_ACTION(PHY_PORT, sizeof(struct rte_flow_action_phy_port)), MK_FLOW_ACTION(PORT_ID, sizeof(struct rte_flow_action_port_id)), + MK_FLOW_ACTION(METER, sizeof(struct rte_flow_action_meter)), + MK_FLOW_ACTION(SECURITY, sizeof(struct rte_flow_action_security)), MK_FLOW_ACTION(OF_SET_MPLS_TTL, sizeof(struct rte_flow_action_of_set_mpls_ttl)), MK_FLOW_ACTION(OF_DEC_MPLS_TTL, 0), @@ -109,8 +143,93 @@ static const struct rte_flow_desc_data rte_flow_desc_action[] = { sizeof(struct rte_flow_action_of_pop_mpls)), MK_FLOW_ACTION(OF_PUSH_MPLS, sizeof(struct rte_flow_action_of_push_mpls)), + MK_FLOW_ACTION(VXLAN_ENCAP, sizeof(struct rte_flow_action_vxlan_encap)), + MK_FLOW_ACTION(VXLAN_DECAP, 0), + MK_FLOW_ACTION(NVGRE_ENCAP, sizeof(struct rte_flow_action_vxlan_encap)), + MK_FLOW_ACTION(NVGRE_DECAP, 0), + MK_FLOW_ACTION(RAW_ENCAP, sizeof(struct rte_flow_action_raw_encap)), + MK_FLOW_ACTION(RAW_DECAP, sizeof(struct rte_flow_action_raw_decap)), + MK_FLOW_ACTION(SET_IPV4_SRC, + sizeof(struct rte_flow_action_set_ipv4)), + MK_FLOW_ACTION(SET_IPV4_DST, + sizeof(struct rte_flow_action_set_ipv4)), + MK_FLOW_ACTION(SET_IPV6_SRC, + sizeof(struct rte_flow_action_set_ipv6)), + MK_FLOW_ACTION(SET_IPV6_DST, + sizeof(struct rte_flow_action_set_ipv6)), + MK_FLOW_ACTION(SET_TP_SRC, + sizeof(struct rte_flow_action_set_tp)), + MK_FLOW_ACTION(SET_TP_DST, + sizeof(struct rte_flow_action_set_tp)), + MK_FLOW_ACTION(MAC_SWAP, 0), + MK_FLOW_ACTION(DEC_TTL, 0), + MK_FLOW_ACTION(SET_TTL, sizeof(struct rte_flow_action_set_ttl)), + MK_FLOW_ACTION(SET_MAC_SRC, sizeof(struct rte_flow_action_set_mac)), + MK_FLOW_ACTION(SET_MAC_DST, sizeof(struct rte_flow_action_set_mac)), + MK_FLOW_ACTION(INC_TCP_SEQ, sizeof(rte_be32_t)), + MK_FLOW_ACTION(DEC_TCP_SEQ, sizeof(rte_be32_t)), + MK_FLOW_ACTION(INC_TCP_ACK, sizeof(rte_be32_t)), + MK_FLOW_ACTION(DEC_TCP_ACK, sizeof(rte_be32_t)), + MK_FLOW_ACTION(SET_TAG, sizeof(struct rte_flow_action_set_tag)), + MK_FLOW_ACTION(SET_META, sizeof(struct rte_flow_action_set_meta)), + MK_FLOW_ACTION(SET_IPV4_DSCP, sizeof(struct rte_flow_action_set_dscp)), + MK_FLOW_ACTION(SET_IPV6_DSCP, sizeof(struct rte_flow_action_set_dscp)), + MK_FLOW_ACTION(AGE, sizeof(struct rte_flow_action_age)), + MK_FLOW_ACTION(SAMPLE, sizeof(struct rte_flow_action_sample)), + /** + * Shared action represented as handle of type + * (struct rte_flow_shared action *) stored in conf field (see + * struct rte_flow_action); no need for additional structure to * store + * shared action handle. + */ + MK_FLOW_ACTION(SHARED, 0), }; +int +rte_flow_dynf_metadata_register(void) +{ + int offset; + int flag; + + static const struct rte_mbuf_dynfield desc_offs = { + .name = RTE_MBUF_DYNFIELD_METADATA_NAME, + .size = sizeof(uint32_t), + .align = __alignof__(uint32_t), + }; + static const struct rte_mbuf_dynflag desc_flag = { + .name = RTE_MBUF_DYNFLAG_METADATA_NAME, + }; + + offset = rte_mbuf_dynfield_register(&desc_offs); + if (offset < 0) + goto error; + flag = rte_mbuf_dynflag_register(&desc_flag); + if (flag < 0) + goto error; + rte_flow_dynf_metadata_offs = offset; + rte_flow_dynf_metadata_mask = (1ULL << flag); + return 0; + +error: + rte_flow_dynf_metadata_offs = -1; + rte_flow_dynf_metadata_mask = 0ULL; + return -rte_errno; +} + +static inline void +fts_enter(struct rte_eth_dev *dev) +{ + if (!(dev->data->dev_flags & RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE)) + pthread_mutex_lock(&dev->data->flow_ops_mutex); +} + +static inline void +fts_exit(struct rte_eth_dev *dev) +{ + if (!(dev->data->dev_flags & RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE)) + pthread_mutex_unlock(&dev->data->flow_ops_mutex); +} + static int flow_err(uint16_t port_id, int ret, struct rte_flow_error *error) { @@ -157,12 +276,16 @@ rte_flow_validate(uint16_t port_id, { const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + int ret; if (unlikely(!ops)) return -rte_errno; - if (likely(!!ops->validate)) - return flow_err(port_id, ops->validate(dev, attr, pattern, - actions, error), error); + if (likely(!!ops->validate)) { + fts_enter(dev); + ret = ops->validate(dev, attr, pattern, actions, error); + fts_exit(dev); + return flow_err(port_id, ret, error); + } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOSYS)); @@ -183,7 +306,9 @@ rte_flow_create(uint16_t port_id, if (unlikely(!ops)) return NULL; if (likely(!!ops->create)) { + fts_enter(dev); flow = ops->create(dev, attr, pattern, actions, error); + fts_exit(dev); if (flow == NULL) flow_err(port_id, -rte_errno, error); return flow; @@ -201,12 +326,16 @@ rte_flow_destroy(uint16_t port_id, { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; if (unlikely(!ops)) return -rte_errno; - if (likely(!!ops->destroy)) - return flow_err(port_id, ops->destroy(dev, flow, error), - error); + if (likely(!!ops->destroy)) { + fts_enter(dev); + ret = ops->destroy(dev, flow, error); + fts_exit(dev); + return flow_err(port_id, ret, error); + } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOSYS)); @@ -219,11 +348,16 @@ rte_flow_flush(uint16_t port_id, { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; if (unlikely(!ops)) return -rte_errno; - if (likely(!!ops->flush)) - return flow_err(port_id, ops->flush(dev, error), error); + if (likely(!!ops->flush)) { + fts_enter(dev); + ret = ops->flush(dev, error); + fts_exit(dev); + return flow_err(port_id, ret, error); + } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOSYS)); @@ -239,12 +373,16 @@ rte_flow_query(uint16_t port_id, { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; if (!ops) return -rte_errno; - if (likely(!!ops->query)) - return flow_err(port_id, ops->query(dev, flow, action, data, - error), error); + if (likely(!!ops->query)) { + fts_enter(dev); + ret = ops->query(dev, flow, action, data, error); + fts_exit(dev); + return flow_err(port_id, ret, error); + } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOSYS)); @@ -258,11 +396,16 @@ rte_flow_isolate(uint16_t port_id, { struct rte_eth_dev *dev = &rte_eth_devices[port_id]; const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; if (!ops) return -rte_errno; - if (likely(!!ops->isolate)) - return flow_err(port_id, ops->isolate(dev, set, error), error); + if (likely(!!ops->isolate)) { + fts_enter(dev); + ret = ops->isolate(dev, set, error); + fts_exit(dev); + return flow_err(port_id, ret, error); + } return rte_flow_error_set(error, ENOSYS, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, rte_strerror(ENOSYS)); @@ -375,7 +518,11 @@ rte_flow_conv_item_spec(void *buf, const size_t size, } break; default: - off = rte_flow_desc_item[item->type].size; + /** + * allow PMD private flow item + */ + off = (int)item->type >= 0 ? + rte_flow_desc_item[item->type].size : sizeof(void *); rte_memcpy(buf, data, (size > off ? off : size)); break; } @@ -406,11 +553,16 @@ rte_flow_conv_action_conf(void *buf, const size_t size, switch (action->type) { union { const struct rte_flow_action_rss *rss; + const struct rte_flow_action_vxlan_encap *vxlan_encap; + const struct rte_flow_action_nvgre_encap *nvgre_encap; } src; union { struct rte_flow_action_rss *rss; + struct rte_flow_action_vxlan_encap *vxlan_encap; + struct rte_flow_action_nvgre_encap *nvgre_encap; } dst; size_t tmp; + int ret; case RTE_FLOW_ACTION_TYPE_RSS: src.rss = action->conf; @@ -444,8 +596,40 @@ rte_flow_conv_action_conf(void *buf, const size_t size, off += tmp; } break; + case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP: + case RTE_FLOW_ACTION_TYPE_NVGRE_ENCAP: + src.vxlan_encap = action->conf; + dst.vxlan_encap = buf; + RTE_BUILD_BUG_ON(sizeof(*src.vxlan_encap) != + sizeof(*src.nvgre_encap) || + offsetof(struct rte_flow_action_vxlan_encap, + definition) != + offsetof(struct rte_flow_action_nvgre_encap, + definition)); + off = sizeof(*dst.vxlan_encap); + if (src.vxlan_encap->definition) { + off = RTE_ALIGN_CEIL + (off, sizeof(*dst.vxlan_encap->definition)); + ret = rte_flow_conv + (RTE_FLOW_CONV_OP_PATTERN, + (void *)((uintptr_t)dst.vxlan_encap + off), + size > off ? size - off : 0, + src.vxlan_encap->definition, NULL); + if (ret < 0) + return 0; + if (size >= off + ret) + dst.vxlan_encap->definition = + (void *)((uintptr_t)dst.vxlan_encap + + off); + off += ret; + } + break; default: - off = rte_flow_desc_action[action->type].size; + /** + * allow PMD private flow action + */ + off = (int)action->type >= 0 ? + rte_flow_desc_action[action->type].size : sizeof(void *); rte_memcpy(buf, action->conf, (size > off ? off : size)); break; } @@ -487,8 +671,12 @@ rte_flow_conv_pattern(struct rte_flow_item *dst, unsigned int i; for (i = 0, off = 0; !num || i != num; ++i, ++src, ++dst) { - if ((size_t)src->type >= RTE_DIM(rte_flow_desc_item) || - !rte_flow_desc_item[src->type].name) + /** + * allow PMD private flow item + */ + if (((int)src->type >= 0) && + ((size_t)src->type >= RTE_DIM(rte_flow_desc_item) || + !rte_flow_desc_item[src->type].name)) return rte_flow_error_set (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, src, "cannot convert unknown item type"); @@ -576,8 +764,12 @@ rte_flow_conv_actions(struct rte_flow_action *dst, unsigned int i; for (i = 0, off = 0; !num || i != num; ++i, ++src, ++dst) { - if ((size_t)src->type >= RTE_DIM(rte_flow_desc_action) || - !rte_flow_desc_action[src->type].name) + /** + * allow PMD private flow action + */ + if (((int)src->type >= 0) && + ((size_t)src->type >= RTE_DIM(rte_flow_desc_action) || + !rte_flow_desc_action[src->type].name)) return rte_flow_error_set (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, src, "cannot convert unknown action type"); @@ -679,6 +871,60 @@ rte_flow_conv_rule(struct rte_flow_conv_rule *dst, return off; } +/** + * Retrieve the name of a pattern item/action type. + * + * @param is_action + * Nonzero when @p src represents an action type instead of a pattern item + * type. + * @param is_ptr + * Nonzero to write string address instead of contents into @p dst. + * @param[out] dst + * Destination buffer. Can be NULL if @p size is zero. + * @param size + * Size of @p dst in bytes. + * @param[in] src + * Depending on @p is_action, source pattern item or action type cast as a + * pointer. + * @param[out] error + * Perform verbose error reporting if not NULL. + * + * @return + * A positive value representing the number of bytes needed to store the + * name or its address regardless of @p size on success (@p buf contents + * are truncated to @p size if not large enough), a negative errno value + * otherwise and rte_errno is set. + */ +static int +rte_flow_conv_name(int is_action, + int is_ptr, + char *dst, + const size_t size, + const void *src, + struct rte_flow_error *error) +{ + struct desc_info { + const struct rte_flow_desc_data *data; + size_t num; + }; + static const struct desc_info info_rep[2] = { + { rte_flow_desc_item, RTE_DIM(rte_flow_desc_item), }, + { rte_flow_desc_action, RTE_DIM(rte_flow_desc_action), }, + }; + const struct desc_info *const info = &info_rep[!!is_action]; + unsigned int type = (uintptr_t)src; + + if (type >= info->num) + return rte_flow_error_set + (error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, + "unknown object type to retrieve the name of"); + if (!is_ptr) + return strlcpy(dst, info->data[type].name, size); + if (size >= sizeof(const char **)) + *((const char **)dst) = info->data[type].name; + return sizeof(const char **); +} + /** Helper function to convert flow API objects. */ int rte_flow_conv(enum rte_flow_conv_op op, @@ -708,6 +954,14 @@ rte_flow_conv(enum rte_flow_conv_op op, return rte_flow_conv_actions(dst, size, src, 0, error); case RTE_FLOW_CONV_OP_RULE: return rte_flow_conv_rule(dst, size, src, error); + case RTE_FLOW_CONV_OP_ITEM_NAME: + return rte_flow_conv_name(0, 0, dst, size, src, error); + case RTE_FLOW_CONV_OP_ACTION_NAME: + return rte_flow_conv_name(1, 0, dst, size, src, error); + case RTE_FLOW_CONV_OP_ITEM_NAME_PTR: + return rte_flow_conv_name(0, 1, dst, size, src, error); + case RTE_FLOW_CONV_OP_ACTION_NAME_PTR: + return rte_flow_conv_name(1, 1, dst, size, src, error); } return rte_flow_error_set (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, @@ -766,109 +1020,239 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, return ret; } -/** - * Expand RSS flows into several possible flows according to the RSS hash - * fields requested and the driver capabilities. - */ -int __rte_experimental -rte_flow_expand_rss(struct rte_flow_expand_rss *buf, size_t size, - const struct rte_flow_item *pattern, uint64_t types, - const struct rte_flow_expand_node graph[], - int graph_root_index) +int +rte_flow_dev_dump(uint16_t port_id, FILE *file, struct rte_flow_error *error) { - const int elt_n = 8; - const struct rte_flow_item *item; - const struct rte_flow_expand_node *node = &graph[graph_root_index]; - const int *next_node; - const int *stack[elt_n]; - int stack_pos = 0; - struct rte_flow_item flow_items[elt_n]; - unsigned int i; - size_t lsize; - size_t user_pattern_size = 0; - void *addr = NULL; - - lsize = offsetof(struct rte_flow_expand_rss, entry) + - elt_n * sizeof(buf->entry[0]); - if (lsize <= size) { - buf->entry[0].priority = 0; - buf->entry[0].pattern = (void *)&buf->entry[elt_n]; - buf->entries = 0; - addr = buf->entry[0].pattern; + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->dev_dump)) { + fts_enter(dev); + ret = ops->dev_dump(dev, file, error); + fts_exit(dev); + return flow_err(port_id, ret, error); } - for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) { - const struct rte_flow_expand_node *next = NULL; + return rte_flow_error_set(error, ENOSYS, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOSYS)); +} - for (i = 0; node->next && node->next[i]; ++i) { - next = &graph[node->next[i]]; - if (next->type == item->type) - break; - } - if (next) - node = next; - user_pattern_size += sizeof(*item); +int +rte_flow_get_aged_flows(uint16_t port_id, void **contexts, + uint32_t nb_contexts, struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + int ret; + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->get_aged_flows)) { + fts_enter(dev); + ret = ops->get_aged_flows(dev, contexts, nb_contexts, error); + fts_exit(dev); + return flow_err(port_id, ret, error); } - user_pattern_size += sizeof(*item); /* Handle END item. */ - lsize += user_pattern_size; - /* Copy the user pattern in the first entry of the buffer. */ - if (lsize <= size) { - rte_memcpy(addr, pattern, user_pattern_size); - addr = (void *)(((uintptr_t)addr) + user_pattern_size); - buf->entries = 1; + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); +} + +struct rte_flow_shared_action * +rte_flow_shared_action_create(uint16_t port_id, + const struct rte_flow_shared_action_conf *conf, + const struct rte_flow_action *action, + struct rte_flow_error *error) +{ + struct rte_flow_shared_action *shared_action; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return NULL; + if (unlikely(!ops->shared_action_create)) { + rte_flow_error_set(error, ENOSYS, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, + rte_strerror(ENOSYS)); + return NULL; } - /* Start expanding. */ - memset(flow_items, 0, sizeof(flow_items)); - user_pattern_size -= sizeof(*item); - next_node = node->next; - stack[stack_pos] = next_node; - node = next_node ? &graph[*next_node] : NULL; - while (node) { - flow_items[stack_pos].type = node->type; - if (node->rss_types & types) { - /* - * compute the number of items to copy from the - * expansion and copy it. - * When the stack_pos is 0, there are 1 element in it, - * plus the addition END item. - */ - int elt = stack_pos + 2; - - flow_items[stack_pos + 1].type = RTE_FLOW_ITEM_TYPE_END; - lsize += elt * sizeof(*item) + user_pattern_size; - if (lsize <= size) { - size_t n = elt * sizeof(*item); - - buf->entry[buf->entries].priority = - stack_pos + 1; - buf->entry[buf->entries].pattern = addr; - buf->entries++; - rte_memcpy(addr, buf->entry[0].pattern, - user_pattern_size); - addr = (void *)(((uintptr_t)addr) + - user_pattern_size); - rte_memcpy(addr, flow_items, n); - addr = (void *)(((uintptr_t)addr) + n); - } - } - /* Go deeper. */ - if (node->next) { - next_node = node->next; - if (stack_pos++ == elt_n) { - rte_errno = E2BIG; - return -rte_errno; - } - stack[stack_pos] = next_node; - } else if (*(next_node + 1)) { - /* Follow up with the next possibility. */ - ++next_node; - } else { - /* Move to the next path. */ - if (stack_pos) - next_node = stack[--stack_pos]; - next_node++; - stack[stack_pos] = next_node; - } - node = *next_node ? &graph[*next_node] : NULL; - }; - return lsize; + shared_action = ops->shared_action_create(&rte_eth_devices[port_id], + conf, action, error); + if (shared_action == NULL) + flow_err(port_id, -rte_errno, error); + return shared_action; +} + +int +rte_flow_shared_action_destroy(uint16_t port_id, + struct rte_flow_shared_action *action, + struct rte_flow_error *error) +{ + int ret; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (unlikely(!ops->shared_action_destroy)) + return rte_flow_error_set(error, ENOSYS, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOSYS)); + ret = ops->shared_action_destroy(&rte_eth_devices[port_id], action, + error); + return flow_err(port_id, ret, error); +} + +int +rte_flow_shared_action_update(uint16_t port_id, + struct rte_flow_shared_action *action, + const struct rte_flow_action *update, + struct rte_flow_error *error) +{ + int ret; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (unlikely(!ops->shared_action_update)) + return rte_flow_error_set(error, ENOSYS, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOSYS)); + ret = ops->shared_action_update(&rte_eth_devices[port_id], action, + update, error); + return flow_err(port_id, ret, error); +} + +int +rte_flow_shared_action_query(uint16_t port_id, + const struct rte_flow_shared_action *action, + void *data, + struct rte_flow_error *error) +{ + int ret; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (unlikely(!ops->shared_action_query)) + return rte_flow_error_set(error, ENOSYS, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOSYS)); + ret = ops->shared_action_query(&rte_eth_devices[port_id], action, + data, error); + return flow_err(port_id, ret, error); +} + +int +rte_flow_tunnel_decap_set(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_action **actions, + uint32_t *num_of_actions, + struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->tunnel_decap_set)) { + return flow_err(port_id, + ops->tunnel_decap_set(dev, tunnel, actions, + num_of_actions, error), + error); + } + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); +} + +int +rte_flow_tunnel_match(uint16_t port_id, + struct rte_flow_tunnel *tunnel, + struct rte_flow_item **items, + uint32_t *num_of_items, + struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->tunnel_match)) { + return flow_err(port_id, + ops->tunnel_match(dev, tunnel, items, + num_of_items, error), + error); + } + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); +} + +int +rte_flow_get_restore_info(uint16_t port_id, + struct rte_mbuf *m, + struct rte_flow_restore_info *restore_info, + struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->get_restore_info)) { + return flow_err(port_id, + ops->get_restore_info(dev, m, restore_info, + error), + error); + } + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); +} + +int +rte_flow_tunnel_action_decap_release(uint16_t port_id, + struct rte_flow_action *actions, + uint32_t num_of_actions, + struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->tunnel_action_decap_release)) { + return flow_err(port_id, + ops->tunnel_action_decap_release(dev, actions, + num_of_actions, + error), + error); + } + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); +} + +int +rte_flow_tunnel_item_release(uint16_t port_id, + struct rte_flow_item *items, + uint32_t num_of_items, + struct rte_flow_error *error) +{ + struct rte_eth_dev *dev = &rte_eth_devices[port_id]; + const struct rte_flow_ops *ops = rte_flow_ops_get(port_id, error); + + if (unlikely(!ops)) + return -rte_errno; + if (likely(!!ops->tunnel_item_release)) { + return flow_err(port_id, + ops->tunnel_item_release(dev, items, + num_of_items, error), + error); + } + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, + NULL, rte_strerror(ENOTSUP)); }