Hi Eli, Thanks for this full-offload patch set. I have some comments inline.
Thanks, -Harsha On Wed, Nov 20, 2019 at 9:07 PM Eli Britstein <[email protected]> wrote: > > Refactor the flow patterns and actions code to a new source files for > better readability and towards adding more code to it. > > Signed-off-by: Eli Britstein <[email protected]> > Reviewed-by: Oz Shlomo <[email protected]> > --- > lib/automake.mk | 4 +- > lib/netdev-offload-dpdk-flow.c | 479 > ++++++++++++++++++++++++++++++++++++++ > lib/netdev-offload-dpdk-private.h | 69 ++++++ > lib/netdev-offload-dpdk.c | 466 +----------------------------------- > 4 files changed, 562 insertions(+), 456 deletions(-) > create mode 100644 lib/netdev-offload-dpdk-flow.c > create mode 100644 lib/netdev-offload-dpdk-private.h > > diff --git a/lib/automake.mk b/lib/automake.mk > index 17b36b43d..3a813af85 100644 > --- a/lib/automake.mk > +++ b/lib/automake.mk > @@ -142,6 +142,7 @@ lib_libopenvswitch_la_SOURCES = \ > lib/netdev-dummy.c \ > lib/netdev-offload.c \ > lib/netdev-offload.h \ > + lib/netdev-offload-dpdk-private.h \ > lib/netdev-offload-provider.h \ > lib/netdev-provider.h \ > lib/netdev-vport.c \ > @@ -426,7 +427,8 @@ if DPDK_NETDEV > lib_libopenvswitch_la_SOURCES += \ > lib/dpdk.c \ > lib/netdev-dpdk.c \ > - lib/netdev-offload-dpdk.c > + lib/netdev-offload-dpdk.c \ > + lib/netdev-offload-dpdk-flow.c 1. The existing netdev-offload-dpdk.c file is not too big - around 700+ lines. Why not add these new functions to the same file ? May be add them in a separate section in that file ? 2. The functions in the new file begin with the prefix netdev_dpdk_. But that same prefix is used by functions in netdev-dpdk.c and it can be confusing. > else > lib_libopenvswitch_la_SOURCES += \ > lib/dpdk-stub.c > diff --git a/lib/netdev-offload-dpdk-flow.c b/lib/netdev-offload-dpdk-flow.c > new file mode 100644 > index 000000000..d1d5ce2c6 > --- /dev/null > +++ b/lib/netdev-offload-dpdk-flow.c > @@ -0,0 +1,479 @@ > +/* > + * Copyright (c) 2019 Mellanox Technologies, Ltd. > + * > + * Licensed under the Apache License, Version 2.0 (the "License"); > + * you may not use this file except in compliance with the License. > + * You may obtain a copy of the License at: > + * > + * http://www.apache.org/licenses/LICENSE-2.0 > + * > + * Unless required by applicable law or agreed to in writing, software > + * distributed under the License is distributed on an "AS IS" BASIS, > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > + * See the License for the specific language governing permissions and > + * limitations under the License. > + */ > +#include <config.h> > + > +#include <rte_flow.h> > + > +#include "dpif-netdev.h" > +#include "netdev-offload-dpdk-private.h" > +#include "openvswitch/match.h" > +#include "openvswitch/vlog.h" > +#include "packets.h" > + > +VLOG_DEFINE_THIS_MODULE(netdev_offload_dpdk_flow); > + > +void > +netdev_dpdk_flow_patterns_free(struct flow_patterns *patterns) > +{ > + /* When calling this function 'patterns' must be valid */ > + free(patterns->items); > + patterns->items = NULL; > + patterns->cnt = 0; > +} > + > +void > +netdev_dpdk_flow_actions_free(struct flow_actions *actions) > +{ > + /* When calling this function 'actions' must be valid */ > + int i; > + > + for (i = 0; i < actions->cnt; i++) { > + if (actions->actions[i].conf) { > + free((void *)actions->actions[i].conf); > + } > + } > + free(actions->actions); > + actions->actions = NULL; > + actions->cnt = 0; > +} > + > +static void > +dump_flow_pattern(struct rte_flow_item *item) > +{ > + struct ds s; > + > + if (!VLOG_IS_DBG_ENABLED() || item->type == RTE_FLOW_ITEM_TYPE_END) { > + return; > + } > + > + ds_init(&s); > + > + if (item->type == RTE_FLOW_ITEM_TYPE_ETH) { > + const struct rte_flow_item_eth *eth_spec = item->spec; > + const struct rte_flow_item_eth *eth_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow eth pattern:\n"); > + if (eth_spec) { > + ds_put_format(&s, > + " Spec: src="ETH_ADDR_FMT", dst="ETH_ADDR_FMT", " > + "type=0x%04" PRIx16"\n", > + ETH_ADDR_BYTES_ARGS(eth_spec->src.addr_bytes), > + ETH_ADDR_BYTES_ARGS(eth_spec->dst.addr_bytes), > + ntohs(eth_spec->type)); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (eth_mask) { > + ds_put_format(&s, > + " Mask: src="ETH_ADDR_FMT", dst="ETH_ADDR_FMT", " > + "type=0x%04"PRIx16"\n", > + ETH_ADDR_BYTES_ARGS(eth_mask->src.addr_bytes), > + ETH_ADDR_BYTES_ARGS(eth_mask->dst.addr_bytes), > + ntohs(eth_mask->type)); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) { > + const struct rte_flow_item_vlan *vlan_spec = item->spec; > + const struct rte_flow_item_vlan *vlan_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow vlan pattern:\n"); > + if (vlan_spec) { > + ds_put_format(&s, > + " Spec: inner_type=0x%"PRIx16", > tci=0x%"PRIx16"\n", > + ntohs(vlan_spec->inner_type), > ntohs(vlan_spec->tci)); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + > + if (vlan_mask) { > + ds_put_format(&s, > + " Mask: inner_type=0x%"PRIx16", > tci=0x%"PRIx16"\n", > + ntohs(vlan_mask->inner_type), > ntohs(vlan_mask->tci)); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) { > + const struct rte_flow_item_ipv4 *ipv4_spec = item->spec; > + const struct rte_flow_item_ipv4 *ipv4_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow ipv4 pattern:\n"); > + if (ipv4_spec) { > + ds_put_format(&s, > + " Spec: tos=0x%"PRIx8", ttl=%"PRIx8 > + ", proto=0x%"PRIx8 > + ", src="IP_FMT", dst="IP_FMT"\n", > + ipv4_spec->hdr.type_of_service, > + ipv4_spec->hdr.time_to_live, > + ipv4_spec->hdr.next_proto_id, > + IP_ARGS(ipv4_spec->hdr.src_addr), > + IP_ARGS(ipv4_spec->hdr.dst_addr)); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (ipv4_mask) { > + ds_put_format(&s, > + " Mask: tos=0x%"PRIx8", ttl=%"PRIx8 > + ", proto=0x%"PRIx8 > + ", src="IP_FMT", dst="IP_FMT"\n", > + ipv4_mask->hdr.type_of_service, > + ipv4_mask->hdr.time_to_live, > + ipv4_mask->hdr.next_proto_id, > + IP_ARGS(ipv4_mask->hdr.src_addr), > + IP_ARGS(ipv4_mask->hdr.dst_addr)); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_UDP) { > + const struct rte_flow_item_udp *udp_spec = item->spec; > + const struct rte_flow_item_udp *udp_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow udp pattern:\n"); > + if (udp_spec) { > + ds_put_format(&s, > + " Spec: src_port=%"PRIu16", dst_port=%"PRIu16"\n", > + ntohs(udp_spec->hdr.src_port), > + ntohs(udp_spec->hdr.dst_port)); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (udp_mask) { > + ds_put_format(&s, > + " Mask: src_port=0x%"PRIx16 > + ", dst_port=0x%"PRIx16"\n", > + ntohs(udp_mask->hdr.src_port), > + ntohs(udp_mask->hdr.dst_port)); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) { > + const struct rte_flow_item_sctp *sctp_spec = item->spec; > + const struct rte_flow_item_sctp *sctp_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow sctp pattern:\n"); > + if (sctp_spec) { > + ds_put_format(&s, > + " Spec: src_port=%"PRIu16", dst_port=%"PRIu16"\n", > + ntohs(sctp_spec->hdr.src_port), > + ntohs(sctp_spec->hdr.dst_port)); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (sctp_mask) { > + ds_put_format(&s, > + " Mask: src_port=0x%"PRIx16 > + ", dst_port=0x%"PRIx16"\n", > + ntohs(sctp_mask->hdr.src_port), > + ntohs(sctp_mask->hdr.dst_port)); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_ICMP) { > + const struct rte_flow_item_icmp *icmp_spec = item->spec; > + const struct rte_flow_item_icmp *icmp_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow icmp pattern:\n"); > + if (icmp_spec) { > + ds_put_format(&s, > + " Spec: icmp_type=%"PRIu8", icmp_code=%"PRIu8"\n", > + icmp_spec->hdr.icmp_type, > + icmp_spec->hdr.icmp_code); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (icmp_mask) { > + ds_put_format(&s, > + " Mask: icmp_type=0x%"PRIx8 > + ", icmp_code=0x%"PRIx8"\n", > + icmp_spec->hdr.icmp_type, > + icmp_spec->hdr.icmp_code); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + if (item->type == RTE_FLOW_ITEM_TYPE_TCP) { > + const struct rte_flow_item_tcp *tcp_spec = item->spec; > + const struct rte_flow_item_tcp *tcp_mask = item->mask; > + > + ds_put_cstr(&s, "rte flow tcp pattern:\n"); > + if (tcp_spec) { > + ds_put_format(&s, > + " Spec: src_port=%"PRIu16", dst_port=%"PRIu16 > + ", data_off=0x%"PRIx8", tcp_flags=0x%"PRIx8"\n", > + ntohs(tcp_spec->hdr.src_port), > + ntohs(tcp_spec->hdr.dst_port), > + tcp_spec->hdr.data_off, > + tcp_spec->hdr.tcp_flags); > + } else { > + ds_put_cstr(&s, " Spec = null\n"); > + } > + if (tcp_mask) { > + ds_put_format(&s, > + " Mask: src_port=%"PRIx16", dst_port=%"PRIx16 > + ", data_off=0x%"PRIx8", tcp_flags=0x%"PRIx8"\n", > + ntohs(tcp_mask->hdr.src_port), > + ntohs(tcp_mask->hdr.dst_port), > + tcp_mask->hdr.data_off, > + tcp_mask->hdr.tcp_flags); > + } else { > + ds_put_cstr(&s, " Mask = null\n"); > + } > + } > + > + VLOG_DBG("%s", ds_cstr(&s)); > + ds_destroy(&s); > +} > + > +static void > +add_flow_pattern(struct flow_patterns *patterns, enum rte_flow_item_type > type, > + const void *spec, const void *mask) > +{ > + int cnt = patterns->cnt; > + > + if (cnt == 0) { > + patterns->current_max = 8; > + patterns->items = xcalloc(patterns->current_max, > + sizeof *patterns->items); > + } else if (cnt == patterns->current_max) { > + patterns->current_max *= 2; > + patterns->items = xrealloc(patterns->items, patterns->current_max * > + sizeof *patterns->items); > + } > + > + patterns->items[cnt].type = type; > + patterns->items[cnt].spec = spec; > + patterns->items[cnt].mask = mask; > + patterns->items[cnt].last = NULL; > + dump_flow_pattern(&patterns->items[cnt]); > + patterns->cnt++; > +} > + > +static void > +add_flow_action(struct flow_actions *actions, enum rte_flow_action_type type, > + const void *conf) > +{ > + int cnt = actions->cnt; > + > + if (cnt == 0) { > + actions->current_max = 8; > + actions->actions = xcalloc(actions->current_max, > + sizeof *actions->actions); > + } else if (cnt == actions->current_max) { > + actions->current_max *= 2; > + actions->actions = xrealloc(actions->actions, actions->current_max * > + sizeof *actions->actions); > + } > + > + actions->actions[cnt].type = type; > + actions->actions[cnt].conf = conf; > + actions->cnt++; > +} > + > +void > +netdev_dpdk_flow_actions_add_mark_rss(struct flow_actions *actions, > + struct netdev *netdev, > + uint32_t mark_id) > +{ > + struct rte_flow_action_mark *mark; > + struct action_rss_data { > + struct rte_flow_action_rss conf; > + uint16_t queue[0]; > + } *rss_data; > + int i; > + > + mark = xmalloc(sizeof *mark); > + rss_data = xmalloc(sizeof *rss_data + > + netdev_n_rxq(netdev) * sizeof rss_data->queue[0]); > + *rss_data = (struct action_rss_data) { > + .conf = (struct rte_flow_action_rss) { > + .func = RTE_ETH_HASH_FUNCTION_DEFAULT, > + .level = 0, > + .types = 0, > + .queue_num = netdev_n_rxq(netdev), > + .queue = rss_data->queue, > + .key_len = 0, > + .key = NULL > + }, > + }; > + > + /* Override queue array with default. */ > + for (i = 0; i < netdev_n_rxq(netdev); i++) { > + rss_data->queue[i] = i; > + } > + > + mark->id = mark_id; > + add_flow_action(actions, RTE_FLOW_ACTION_TYPE_MARK, mark); > + add_flow_action(actions, RTE_FLOW_ACTION_TYPE_RSS, &rss_data->conf); > + add_flow_action(actions, RTE_FLOW_ACTION_TYPE_END, NULL); > +} > + > +int > +netdev_dpdk_flow_patterns_add(struct flow_patterns *patterns, > + struct flow_pattern_items *spec, > + struct flow_pattern_items *mask, > + const struct match *match) > +{ > + uint8_t proto = 0; > + > + /* Eth */ > + if (!eth_addr_is_zero(match->wc.masks.dl_src) || > + !eth_addr_is_zero(match->wc.masks.dl_dst)) { > + memcpy(&spec->eth.dst, &match->flow.dl_dst, sizeof spec->eth.dst); > + memcpy(&spec->eth.src, &match->flow.dl_src, sizeof spec->eth.src); > + spec->eth.type = match->flow.dl_type; > + > + memcpy(&mask->eth.dst, &match->wc.masks.dl_dst, sizeof > mask->eth.dst); > + memcpy(&mask->eth.src, &match->wc.masks.dl_src, sizeof > mask->eth.src); > + mask->eth.type = match->wc.masks.dl_type; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_ETH, > + &spec->eth, &mask->eth); > + } else { > + /* > + * If user specifies a flow (like UDP flow) without L2 patterns, > + * OVS will at least set the dl_type. Normally, it's enough to > + * create an eth pattern just with it. Unluckily, some Intel's > + * NIC (such as XL710) doesn't support that. Below is a workaround, > + * which simply matches any L2 pkts. > + */ > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_ETH, NULL, NULL); > + } > + > + /* VLAN */ > + if (match->wc.masks.vlans[0].tci && match->flow.vlans[0].tci) { > + spec->vlan.tci = match->flow.vlans[0].tci & ~htons(VLAN_CFI); > + mask->vlan.tci = match->wc.masks.vlans[0].tci & ~htons(VLAN_CFI); > + > + /* Match any protocols. */ > + mask->vlan.inner_type = 0; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_VLAN, > + &spec->vlan, &mask->vlan); > + } > + > + /* IP v4 */ > + if (match->flow.dl_type == htons(ETH_TYPE_IP)) { > + spec->ipv4.hdr.type_of_service = match->flow.nw_tos; > + spec->ipv4.hdr.time_to_live = match->flow.nw_ttl; > + spec->ipv4.hdr.next_proto_id = match->flow.nw_proto; > + spec->ipv4.hdr.src_addr = match->flow.nw_src; > + spec->ipv4.hdr.dst_addr = match->flow.nw_dst; > + > + mask->ipv4.hdr.type_of_service = match->wc.masks.nw_tos; > + mask->ipv4.hdr.time_to_live = match->wc.masks.nw_ttl; > + mask->ipv4.hdr.next_proto_id = match->wc.masks.nw_proto; > + mask->ipv4.hdr.src_addr = match->wc.masks.nw_src; > + mask->ipv4.hdr.dst_addr = match->wc.masks.nw_dst; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_IPV4, > + &spec->ipv4, &mask->ipv4); > + > + /* Save proto for L4 protocol setup. */ > + proto = spec->ipv4.hdr.next_proto_id & > + mask->ipv4.hdr.next_proto_id; > + } > + > + if (proto != IPPROTO_ICMP && proto != IPPROTO_UDP && > + proto != IPPROTO_SCTP && proto != IPPROTO_TCP && > + (match->wc.masks.tp_src || > + match->wc.masks.tp_dst || > + match->wc.masks.tcp_flags)) { > + VLOG_DBG("L4 Protocol (%u) not supported", proto); > + return -1; > + } > + > + if ((match->wc.masks.tp_src && match->wc.masks.tp_src != OVS_BE16_MAX) || > + (match->wc.masks.tp_dst && match->wc.masks.tp_dst != OVS_BE16_MAX)) { > + return -1; > + } > + > + switch (proto) { > + case IPPROTO_TCP: > + spec->tcp.hdr.src_port = match->flow.tp_src; > + spec->tcp.hdr.dst_port = match->flow.tp_dst; > + spec->tcp.hdr.data_off = ntohs(match->flow.tcp_flags) >> 8; > + spec->tcp.hdr.tcp_flags = ntohs(match->flow.tcp_flags) & 0xff; > + > + mask->tcp.hdr.src_port = match->wc.masks.tp_src; > + mask->tcp.hdr.dst_port = match->wc.masks.tp_dst; > + mask->tcp.hdr.data_off = ntohs(match->wc.masks.tcp_flags) >> 8; > + mask->tcp.hdr.tcp_flags = ntohs(match->wc.masks.tcp_flags) & 0xff; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_TCP, > + &spec->tcp, &mask->tcp); > + > + /* proto == TCP and ITEM_TYPE_TCP, thus no need for proto match. */ > + mask->ipv4.hdr.next_proto_id = 0; > + break; > + > + case IPPROTO_UDP: > + spec->udp.hdr.src_port = match->flow.tp_src; > + spec->udp.hdr.dst_port = match->flow.tp_dst; > + > + mask->udp.hdr.src_port = match->wc.masks.tp_src; > + mask->udp.hdr.dst_port = match->wc.masks.tp_dst; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_UDP, > + &spec->udp, &mask->udp); > + > + /* proto == UDP and ITEM_TYPE_UDP, thus no need for proto match. */ > + mask->ipv4.hdr.next_proto_id = 0; > + break; > + > + case IPPROTO_SCTP: > + spec->sctp.hdr.src_port = match->flow.tp_src; > + spec->sctp.hdr.dst_port = match->flow.tp_dst; > + > + mask->sctp.hdr.src_port = match->wc.masks.tp_src; > + mask->sctp.hdr.dst_port = match->wc.masks.tp_dst; > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_SCTP, > + &spec->sctp, &mask->sctp); > + > + /* proto == SCTP and ITEM_TYPE_SCTP, thus no need for proto match. */ > + mask->ipv4.hdr.next_proto_id = 0; > + break; > + > + case IPPROTO_ICMP: > + spec->icmp.hdr.icmp_type = (uint8_t) ntohs(match->flow.tp_src); > + spec->icmp.hdr.icmp_code = (uint8_t) ntohs(match->flow.tp_dst); > + > + mask->icmp.hdr.icmp_type = (uint8_t) ntohs(match->wc.masks.tp_src); > + mask->icmp.hdr.icmp_code = (uint8_t) ntohs(match->wc.masks.tp_dst); > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_ICMP, > + &spec->icmp, &mask->icmp); > + > + /* proto == ICMP and ITEM_TYPE_ICMP, thus no need for proto match. */ > + mask->ipv4.hdr.next_proto_id = 0; > + break; > + } > + > + add_flow_pattern(patterns, RTE_FLOW_ITEM_TYPE_END, NULL, NULL); > + return 0; > +} > + > diff --git a/lib/netdev-offload-dpdk-private.h > b/lib/netdev-offload-dpdk-private.h > new file mode 100644 > index 000000000..397384cb0 > --- /dev/null > +++ b/lib/netdev-offload-dpdk-private.h > @@ -0,0 +1,69 @@ > +/* > + * Copyright (c) 2019 Mellanox Technologies, Ltd. > + * > + * Licensed under the Apache License, Version 2.0 (the "License"); > + * you may not use this file except in compliance with the License. > + * You may obtain a copy of the License at: > + * > + * http://www.apache.org/licenses/LICENSE-2.0 > + * > + * Unless required by applicable law or agreed to in writing, software > + * distributed under the License is distributed on an "AS IS" BASIS, > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > + * See the License for the specific language governing permissions and > + * limitations under the License. > + */ > + > +#ifndef NETDEV_OFFLOAD_DPDK_PRIVATE_H > +#define NETDEV_OFFLOAD_DPDK_PRIVATE_H > + > +#include "openvswitch/match.h" > + > +#include <rte_flow.h> > + > +struct netdev; > + > +/* > + * To avoid individual xrealloc calls for each new element, a 'curent_max' > + * is used to keep track of current allocated number of elements. Starts > + * by 8 and doubles on each xrealloc call. > + */ > +struct flow_patterns { > + struct rte_flow_item *items; > + int cnt; > + int current_max; > +}; > + > +struct flow_actions { > + struct rte_flow_action *actions; > + int cnt; > + int current_max; > +}; > + > +struct flow_pattern_items { > + struct rte_flow_item_eth eth; > + struct rte_flow_item_vlan vlan; > + struct rte_flow_item_ipv4 ipv4; > + union { > + struct rte_flow_item_tcp tcp; > + struct rte_flow_item_udp udp; > + struct rte_flow_item_sctp sctp; > + struct rte_flow_item_icmp icmp; > + }; > +}; > + > +void > +netdev_dpdk_flow_patterns_free(struct flow_patterns *patterns); > +int > +netdev_dpdk_flow_patterns_add(struct flow_patterns *patterns, > + struct flow_pattern_items *spec, > + struct flow_pattern_items *mask, > + const struct match *match); > +void > +netdev_dpdk_flow_actions_free(struct flow_actions *actions); > +void > +netdev_dpdk_flow_actions_add_mark_rss(struct flow_actions *actions, > + struct netdev *netdev, > + uint32_t mark_id); > + > +#endif /* NETDEV_OFFLOAD_DPDK_PRIVATE_H */ > diff --git a/lib/netdev-offload-dpdk.c b/lib/netdev-offload-dpdk.c > index 96794dc4d..d6bbb7166 100644 > --- a/lib/netdev-offload-dpdk.c > +++ b/lib/netdev-offload-dpdk.c > @@ -26,6 +26,7 @@ > #include "openvswitch/vlog.h" > #include "packets.h" > #include "uuid.h" > +#include "netdev-offload-dpdk-private.h" > > VLOG_DEFINE_THIS_MODULE(netdev_offload_dpdk); > > @@ -114,302 +115,6 @@ ufid_to_rte_flow_disassociate(const ovs_u128 *ufid) > UUID_ARGS((struct uuid *) ufid)); > } > > -/* > - * To avoid individual xrealloc calls for each new element, a 'curent_max' > - * is used to keep track of current allocated number of elements. Starts > - * by 8 and doubles on each xrealloc call. > - */ > -struct flow_patterns { > - struct rte_flow_item *items; > - int cnt; > - int current_max; > -}; > - > -struct flow_actions { > - struct rte_flow_action *actions; > - int cnt; > - int current_max; > -}; > - > -static void > -dump_flow_pattern(struct rte_flow_item *item) > -{ > - struct ds s; > - > - if (!VLOG_IS_DBG_ENABLED() || item->type == RTE_FLOW_ITEM_TYPE_END) { > - return; > - } > - > - ds_init(&s); > - > - if (item->type == RTE_FLOW_ITEM_TYPE_ETH) { > - const struct rte_flow_item_eth *eth_spec = item->spec; > - const struct rte_flow_item_eth *eth_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow eth pattern:\n"); > - if (eth_spec) { > - ds_put_format(&s, > - " Spec: src="ETH_ADDR_FMT", dst="ETH_ADDR_FMT", " > - "type=0x%04" PRIx16"\n", > - ETH_ADDR_BYTES_ARGS(eth_spec->src.addr_bytes), > - ETH_ADDR_BYTES_ARGS(eth_spec->dst.addr_bytes), > - ntohs(eth_spec->type)); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (eth_mask) { > - ds_put_format(&s, > - " Mask: src="ETH_ADDR_FMT", dst="ETH_ADDR_FMT", " > - "type=0x%04"PRIx16"\n", > - ETH_ADDR_BYTES_ARGS(eth_mask->src.addr_bytes), > - ETH_ADDR_BYTES_ARGS(eth_mask->dst.addr_bytes), > - ntohs(eth_mask->type)); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) { > - const struct rte_flow_item_vlan *vlan_spec = item->spec; > - const struct rte_flow_item_vlan *vlan_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow vlan pattern:\n"); > - if (vlan_spec) { > - ds_put_format(&s, > - " Spec: inner_type=0x%"PRIx16", > tci=0x%"PRIx16"\n", > - ntohs(vlan_spec->inner_type), > ntohs(vlan_spec->tci)); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - > - if (vlan_mask) { > - ds_put_format(&s, > - " Mask: inner_type=0x%"PRIx16", > tci=0x%"PRIx16"\n", > - ntohs(vlan_mask->inner_type), > ntohs(vlan_mask->tci)); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) { > - const struct rte_flow_item_ipv4 *ipv4_spec = item->spec; > - const struct rte_flow_item_ipv4 *ipv4_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow ipv4 pattern:\n"); > - if (ipv4_spec) { > - ds_put_format(&s, > - " Spec: tos=0x%"PRIx8", ttl=%"PRIx8 > - ", proto=0x%"PRIx8 > - ", src="IP_FMT", dst="IP_FMT"\n", > - ipv4_spec->hdr.type_of_service, > - ipv4_spec->hdr.time_to_live, > - ipv4_spec->hdr.next_proto_id, > - IP_ARGS(ipv4_spec->hdr.src_addr), > - IP_ARGS(ipv4_spec->hdr.dst_addr)); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (ipv4_mask) { > - ds_put_format(&s, > - " Mask: tos=0x%"PRIx8", ttl=%"PRIx8 > - ", proto=0x%"PRIx8 > - ", src="IP_FMT", dst="IP_FMT"\n", > - ipv4_mask->hdr.type_of_service, > - ipv4_mask->hdr.time_to_live, > - ipv4_mask->hdr.next_proto_id, > - IP_ARGS(ipv4_mask->hdr.src_addr), > - IP_ARGS(ipv4_mask->hdr.dst_addr)); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_UDP) { > - const struct rte_flow_item_udp *udp_spec = item->spec; > - const struct rte_flow_item_udp *udp_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow udp pattern:\n"); > - if (udp_spec) { > - ds_put_format(&s, > - " Spec: src_port=%"PRIu16", dst_port=%"PRIu16"\n", > - ntohs(udp_spec->hdr.src_port), > - ntohs(udp_spec->hdr.dst_port)); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (udp_mask) { > - ds_put_format(&s, > - " Mask: src_port=0x%"PRIx16 > - ", dst_port=0x%"PRIx16"\n", > - ntohs(udp_mask->hdr.src_port), > - ntohs(udp_mask->hdr.dst_port)); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) { > - const struct rte_flow_item_sctp *sctp_spec = item->spec; > - const struct rte_flow_item_sctp *sctp_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow sctp pattern:\n"); > - if (sctp_spec) { > - ds_put_format(&s, > - " Spec: src_port=%"PRIu16", dst_port=%"PRIu16"\n", > - ntohs(sctp_spec->hdr.src_port), > - ntohs(sctp_spec->hdr.dst_port)); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (sctp_mask) { > - ds_put_format(&s, > - " Mask: src_port=0x%"PRIx16 > - ", dst_port=0x%"PRIx16"\n", > - ntohs(sctp_mask->hdr.src_port), > - ntohs(sctp_mask->hdr.dst_port)); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_ICMP) { > - const struct rte_flow_item_icmp *icmp_spec = item->spec; > - const struct rte_flow_item_icmp *icmp_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow icmp pattern:\n"); > - if (icmp_spec) { > - ds_put_format(&s, > - " Spec: icmp_type=%"PRIu8", icmp_code=%"PRIu8"\n", > - icmp_spec->hdr.icmp_type, > - icmp_spec->hdr.icmp_code); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (icmp_mask) { > - ds_put_format(&s, > - " Mask: icmp_type=0x%"PRIx8 > - ", icmp_code=0x%"PRIx8"\n", > - icmp_spec->hdr.icmp_type, > - icmp_spec->hdr.icmp_code); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - if (item->type == RTE_FLOW_ITEM_TYPE_TCP) { > - const struct rte_flow_item_tcp *tcp_spec = item->spec; > - const struct rte_flow_item_tcp *tcp_mask = item->mask; > - > - ds_put_cstr(&s, "rte flow tcp pattern:\n"); > - if (tcp_spec) { > - ds_put_format(&s, > - " Spec: src_port=%"PRIu16", dst_port=%"PRIu16 > - ", data_off=0x%"PRIx8", tcp_flags=0x%"PRIx8"\n", > - ntohs(tcp_spec->hdr.src_port), > - ntohs(tcp_spec->hdr.dst_port), > - tcp_spec->hdr.data_off, > - tcp_spec->hdr.tcp_flags); > - } else { > - ds_put_cstr(&s, " Spec = null\n"); > - } > - if (tcp_mask) { > - ds_put_format(&s, > - " Mask: src_port=%"PRIx16", dst_port=%"PRIx16 > - ", data_off=0x%"PRIx8", tcp_flags=0x%"PRIx8"\n", > - ntohs(tcp_mask->hdr.src_port), > - ntohs(tcp_mask->hdr.dst_port), > - tcp_mask->hdr.data_off, > - tcp_mask->hdr.tcp_flags); > - } else { > - ds_put_cstr(&s, " Mask = null\n"); > - } > - } > - > - VLOG_DBG("%s", ds_cstr(&s)); > - ds_destroy(&s); > -} > - > -static void > -add_flow_pattern(struct flow_patterns *patterns, enum rte_flow_item_type > type, > - const void *spec, const void *mask) > -{ > - int cnt = patterns->cnt; > - > - if (cnt == 0) { > - patterns->current_max = 8; > - patterns->items = xcalloc(patterns->current_max, > - sizeof *patterns->items); > - } else if (cnt == patterns->current_max) { > - patterns->current_max *= 2; > - patterns->items = xrealloc(patterns->items, patterns->current_max * > - sizeof *patterns->items); > - } > - > - patterns->items[cnt].type = type; > - patterns->items[cnt].spec = spec; > - patterns->items[cnt].mask = mask; > - patterns->items[cnt].last = NULL; > - dump_flow_pattern(&patterns->items[cnt]); > - patterns->cnt++; > -} > - > -static void > -add_flow_action(struct flow_actions *actions, enum rte_flow_action_type type, > - const void *conf) > -{ > - int cnt = actions->cnt; > - > - if (cnt == 0) { > - actions->current_max = 8; > - actions->actions = xcalloc(actions->current_max, > - sizeof *actions->actions); > - } else if (cnt == actions->current_max) { > - actions->current_max *= 2; > - actions->actions = xrealloc(actions->actions, actions->current_max * > - sizeof *actions->actions); > - } > - > - actions->actions[cnt].type = type; > - actions->actions[cnt].conf = conf; > - actions->cnt++; > -} > - > -struct action_rss_data { > - struct rte_flow_action_rss conf; > - uint16_t queue[0]; > -}; > - > -static struct action_rss_data * > -add_flow_rss_action(struct flow_actions *actions, > - struct netdev *netdev) > -{ > - int i; > - struct action_rss_data *rss_data; > - > - rss_data = xmalloc(sizeof *rss_data + > - netdev_n_rxq(netdev) * sizeof rss_data->queue[0]); > - *rss_data = (struct action_rss_data) { > - .conf = (struct rte_flow_action_rss) { > - .func = RTE_ETH_HASH_FUNCTION_DEFAULT, > - .level = 0, > - .types = 0, > - .queue_num = netdev_n_rxq(netdev), > - .queue = rss_data->queue, > - .key_len = 0, > - .key = NULL > - }, > - }; > - > - /* Override queue array with default. */ > - for (i = 0; i < netdev_n_rxq(netdev); i++) { > - rss_data->queue[i] = i; > - } > - > - add_flow_action(actions, RTE_FLOW_ACTION_TYPE_RSS, &rss_data->conf); > - > - return rss_data; > -} > - > static int > netdev_offload_dpdk_add_flow(struct netdev *netdev, > const struct match *match, > @@ -426,177 +131,28 @@ netdev_offload_dpdk_add_flow(struct netdev *netdev, > }; > struct flow_patterns patterns = { .items = NULL, .cnt = 0 }; > struct flow_actions actions = { .actions = NULL, .cnt = 0 }; > - struct rte_flow *flow; > + struct flow_pattern_items spec, mask; > struct rte_flow_error error; > - uint8_t proto = 0; > + struct rte_flow *flow; > int ret = 0; > - struct flow_items { > - struct rte_flow_item_eth eth; > - struct rte_flow_item_vlan vlan; > - struct rte_flow_item_ipv4 ipv4; > - union { > - struct rte_flow_item_tcp tcp; > - struct rte_flow_item_udp udp; > - struct rte_flow_item_sctp sctp; > - struct rte_flow_item_icmp icmp; > - }; > - } spec, mask; > > memset(&spec, 0, sizeof spec); > memset(&mask, 0, sizeof mask); > > - /* Eth */ > - if (!eth_addr_is_zero(match->wc.masks.dl_src) || > - !eth_addr_is_zero(match->wc.masks.dl_dst)) { > - memcpy(&spec.eth.dst, &match->flow.dl_dst, sizeof spec.eth.dst); > - memcpy(&spec.eth.src, &match->flow.dl_src, sizeof spec.eth.src); > - spec.eth.type = match->flow.dl_type; > - > - memcpy(&mask.eth.dst, &match->wc.masks.dl_dst, sizeof mask.eth.dst); > - memcpy(&mask.eth.src, &match->wc.masks.dl_src, sizeof mask.eth.src); > - mask.eth.type = match->wc.masks.dl_type; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_ETH, > - &spec.eth, &mask.eth); > - } else { > - /* > - * If user specifies a flow (like UDP flow) without L2 patterns, > - * OVS will at least set the dl_type. Normally, it's enough to > - * create an eth pattern just with it. Unluckily, some Intel's > - * NIC (such as XL710) doesn't support that. Below is a workaround, > - * which simply matches any L2 pkts. > - */ > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_ETH, NULL, NULL); > - } > - > - /* VLAN */ > - if (match->wc.masks.vlans[0].tci && match->flow.vlans[0].tci) { > - spec.vlan.tci = match->flow.vlans[0].tci & ~htons(VLAN_CFI); > - mask.vlan.tci = match->wc.masks.vlans[0].tci & ~htons(VLAN_CFI); > - > - /* Match any protocols. */ > - mask.vlan.inner_type = 0; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_VLAN, > - &spec.vlan, &mask.vlan); > - } > - > - /* IP v4 */ > - if (match->flow.dl_type == htons(ETH_TYPE_IP)) { > - spec.ipv4.hdr.type_of_service = match->flow.nw_tos; > - spec.ipv4.hdr.time_to_live = match->flow.nw_ttl; > - spec.ipv4.hdr.next_proto_id = match->flow.nw_proto; > - spec.ipv4.hdr.src_addr = match->flow.nw_src; > - spec.ipv4.hdr.dst_addr = match->flow.nw_dst; > - > - mask.ipv4.hdr.type_of_service = match->wc.masks.nw_tos; > - mask.ipv4.hdr.time_to_live = match->wc.masks.nw_ttl; > - mask.ipv4.hdr.next_proto_id = match->wc.masks.nw_proto; > - mask.ipv4.hdr.src_addr = match->wc.masks.nw_src; > - mask.ipv4.hdr.dst_addr = match->wc.masks.nw_dst; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_IPV4, > - &spec.ipv4, &mask.ipv4); > - > - /* Save proto for L4 protocol setup. */ > - proto = spec.ipv4.hdr.next_proto_id & > - mask.ipv4.hdr.next_proto_id; > - } > - > - if (proto != IPPROTO_ICMP && proto != IPPROTO_UDP && > - proto != IPPROTO_SCTP && proto != IPPROTO_TCP && > - (match->wc.masks.tp_src || > - match->wc.masks.tp_dst || > - match->wc.masks.tcp_flags)) { > - VLOG_DBG("L4 Protocol (%u) not supported", proto); > - ret = -1; > + ret = netdev_dpdk_flow_patterns_add(&patterns, &spec, &mask, match); > + if (ret) { > + VLOG_WARN("Adding rte match patterns for flow ufid"UUID_FMT" failed", > + UUID_ARGS((struct uuid *)ufid)); > goto out; > } > > - if ((match->wc.masks.tp_src && match->wc.masks.tp_src != OVS_BE16_MAX) || > - (match->wc.masks.tp_dst && match->wc.masks.tp_dst != OVS_BE16_MAX)) { > - ret = -1; > - goto out; > - } > - > - switch (proto) { > - case IPPROTO_TCP: > - spec.tcp.hdr.src_port = match->flow.tp_src; > - spec.tcp.hdr.dst_port = match->flow.tp_dst; > - spec.tcp.hdr.data_off = ntohs(match->flow.tcp_flags) >> 8; > - spec.tcp.hdr.tcp_flags = ntohs(match->flow.tcp_flags) & 0xff; > - > - mask.tcp.hdr.src_port = match->wc.masks.tp_src; > - mask.tcp.hdr.dst_port = match->wc.masks.tp_dst; > - mask.tcp.hdr.data_off = ntohs(match->wc.masks.tcp_flags) >> 8; > - mask.tcp.hdr.tcp_flags = ntohs(match->wc.masks.tcp_flags) & 0xff; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_TCP, > - &spec.tcp, &mask.tcp); > - > - /* proto == TCP and ITEM_TYPE_TCP, thus no need for proto match. */ > - mask.ipv4.hdr.next_proto_id = 0; > - break; > - > - case IPPROTO_UDP: > - spec.udp.hdr.src_port = match->flow.tp_src; > - spec.udp.hdr.dst_port = match->flow.tp_dst; > - > - mask.udp.hdr.src_port = match->wc.masks.tp_src; > - mask.udp.hdr.dst_port = match->wc.masks.tp_dst; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_UDP, > - &spec.udp, &mask.udp); > - > - /* proto == UDP and ITEM_TYPE_UDP, thus no need for proto match. */ > - mask.ipv4.hdr.next_proto_id = 0; > - break; > - > - case IPPROTO_SCTP: > - spec.sctp.hdr.src_port = match->flow.tp_src; > - spec.sctp.hdr.dst_port = match->flow.tp_dst; > - > - mask.sctp.hdr.src_port = match->wc.masks.tp_src; > - mask.sctp.hdr.dst_port = match->wc.masks.tp_dst; > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_SCTP, > - &spec.sctp, &mask.sctp); > - > - /* proto == SCTP and ITEM_TYPE_SCTP, thus no need for proto match. */ > - mask.ipv4.hdr.next_proto_id = 0; > - break; > - > - case IPPROTO_ICMP: > - spec.icmp.hdr.icmp_type = (uint8_t) ntohs(match->flow.tp_src); > - spec.icmp.hdr.icmp_code = (uint8_t) ntohs(match->flow.tp_dst); > - > - mask.icmp.hdr.icmp_type = (uint8_t) ntohs(match->wc.masks.tp_src); > - mask.icmp.hdr.icmp_code = (uint8_t) ntohs(match->wc.masks.tp_dst); > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_ICMP, > - &spec.icmp, &mask.icmp); > - > - /* proto == ICMP and ITEM_TYPE_ICMP, thus no need for proto match. */ > - mask.ipv4.hdr.next_proto_id = 0; > - break; > - } > - > - add_flow_pattern(&patterns, RTE_FLOW_ITEM_TYPE_END, NULL, NULL); > - > - struct rte_flow_action_mark mark; > - struct action_rss_data *rss; > - > - mark.id = info->flow_mark; > - add_flow_action(&actions, RTE_FLOW_ACTION_TYPE_MARK, &mark); > - > - rss = add_flow_rss_action(&actions, netdev); > - add_flow_action(&actions, RTE_FLOW_ACTION_TYPE_END, NULL); > + netdev_dpdk_flow_actions_add_mark_rss(&actions, netdev, > + info->flow_mark); > > flow = netdev_dpdk_rte_flow_create(netdev, &flow_attr, > patterns.items, > actions.actions, &error); > > - free(rss); > if (!flow) { > VLOG_ERR("%s: rte flow creat error: %u : message : %s\n", > netdev_get_name(netdev), error.type, error.message); > @@ -608,8 +164,8 @@ netdev_offload_dpdk_add_flow(struct netdev *netdev, > netdev_get_name(netdev), flow, UUID_ARGS((struct uuid *)ufid)); > > out: > - free(patterns.items); > - free(actions.actions); > + netdev_dpdk_flow_patterns_free(&patterns); > + netdev_dpdk_flow_actions_free(&actions); > return ret; > } > > -- > 2.14.5 > > > _______________________________________________ > dev mailing list > [email protected] > https://mail.openvswitch.org/mailman/listinfo/ovs-dev _______________________________________________ dev mailing list [email protected] https://mail.openvswitch.org/mailman/listinfo/ovs-dev
