add flow_rule infrastructure
Subsystems (14)
v5 cover add flow_rule infrastructure
Hi,
This is another iteration of the in-kernel intermediate representation (IR) that allows to express ACL hardware offloads using one unified representation from the driver side for the ethtool and the tc frontends [1] [2] [3].
In words of Michal Kubecek:
"... the ethtool interface can apply four types of action to matching packets:
- put into a specific queue
- discard
- distribute accross the queues according to a RSS context
- use the rule as a wake-on-lan filter"
This new round now supports for these four types, that can be mapped to the flow_rule representation.
Changes from previous version:
* Michal Kubecek:
- Add support for FLOW_RSS flag to the ethtool_rx_flow_spec to flow_rule translator.
* Venkat Duvvuru:
- Fix accidental swapping of flow_stats_update() bytes and packets parameter.
* kbuild robot:
- Fix double kfree in error path from cls_flower, via Julian Lawal.
- Fix enum type mismatch in nfp driver reported by sparse checks.
Please apply, thanks.
Pablo Neira Ayuso (12):
flow_offload: add flow_rule and flow_match structures and use them net/mlx5e: support for two independent packet edit actions
flow_offload: add flow action infrastructure
cls_api: add translator to flow_action representation
flow_offload: add statistics retrieval infrastructure and use it
drivers: net: use flow action infrastructure
cls_flower: don't expose TC actions to drivers anymore
flow_offload: add wake-up-on-lan and queue to flow_action
ethtool: add ethtool_rx_flow_spec to flow_rule structure translator
dsa: bcm_sf2: use flow_rule infrastructure
qede: place ethtool_rx_flow_spec after code after TC flower codebase
qede: use ethtool_rx_flow_rule() to remove duplicated parser code
drivers/net/dsa/bcm_sf2_cfp.c | 102 ++- drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c | 252 +++---- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 450 ++++++------- drivers/net/ethernet/intel/i40e/i40e_main.c | 178 ++--- drivers/net/ethernet/intel/iavf/iavf_main.c | 195 +++--- drivers/net/ethernet/intel/igb/igb_main.c | 64 +- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 743 ++++++++++----------- drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c | 2 +- .../net/ethernet/mellanox/mlxsw/spectrum_flower.c | 258 ++++--- drivers/net/ethernet/netronome/nfp/flower/action.c | 198 +++--- drivers/net/ethernet/netronome/nfp/flower/match.c | 417 ++++++------ .../net/ethernet/netronome/nfp/flower/offload.c | 150 ++--- drivers/net/ethernet/qlogic/qede/qede_filter.c | 572 ++++++---------- include/linux/ethtool.h | 15 + include/net/flow_offload.h | 202 ++++++ include/net/pkt_cls.h | 18 +- net/core/Makefile | 2 +- net/core/ethtool.c | 240 +++++++ net/core/flow_offload.c | 153 +++++ net/sched/cls_api.c | 116 ++++ net/sched/cls_flower.c | 71 +- 21 files changed, 2403 insertions(+), 1995 deletions(-) create mode 100644 include/net/flow_offload.h create mode 100644 net/core/flow_offload.c
Signature · 1 line
2.11.0
PATCH v5 1/12 flow_offload: add flow_rule and flow_match structures and use them
This patch wraps the dissector key and mask - that flower uses to represent the matching side - around the flow_match structure.
To avoid a follow up patch that would edit the same LoCs in the drivers, this patch also wraps this new flow match structure around the flow rule object. This new structure will also contain the flow actions in follow up patches.
This introduces two new interfaces:
bool flow_rule_match_key(rule, dissector_id)
that returns true if a given matching key is set on, and:
flow_rule_match_XYZ(rule, &match);
To fetch the matching side XYZ into the match container structure, to retrieve the key and the mask with one single call.
---
v5: fix double kfree in cls_flower error path, reported by kbuild robot
via Julia Lawal.
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c | 174 ++++----- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 194 ++++------ drivers/net/ethernet/intel/i40e/i40e_main.c | 178 ++++----- drivers/net/ethernet/intel/iavf/iavf_main.c | 195 ++++------ drivers/net/ethernet/intel/igb/igb_main.c | 64 ++-- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 420 +++++++++------------ .../net/ethernet/mellanox/mlxsw/spectrum_flower.c | 202 +++++----- drivers/net/ethernet/netronome/nfp/flower/action.c | 11 +- drivers/net/ethernet/netronome/nfp/flower/match.c | 417 ++++++++++---------- .../net/ethernet/netronome/nfp/flower/offload.c | 145 +++---- drivers/net/ethernet/qlogic/qede/qede_filter.c | 85 ++--- include/net/flow_offload.h | 115 ++++++ include/net/pkt_cls.h | 11 +- net/core/Makefile | 2 +- net/core/flow_offload.c | 143 +++++++ net/sched/cls_flower.c | 47 ++- 16 files changed, 1196 insertions(+), 1207 deletions(-) create mode 100644 include/net/flow_offload.h create mode 100644 net/core/flow_offload.c
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c +74 -100
@@ -177,18 +177,12 @@ static int bnxt_tc_parse_actions(struct bnxt *bp,return 0 ; } -#define GET_KEY (flow_cmd, key_type) \ - skb_flow_dissector_target((flow_cmd)->dissector, key_type,\ - (flow_cmd)->key) -#define GET_MASK (flow_cmd, key_type) \ - skb_flow_dissector_target((flow_cmd)->dissector, key_type,\ - (flow_cmd)->mask) -static int bnxt_tc_parse_flow (struct bnxt *bp,struct tc_cls_flower_offload *tc_flow_cmd,struct bnxt_tc_flow *flow) { -struct flow_dissector *dissector = tc_flow_cmd->dissector; +struct flow_rule *rule =tc_cls_flower_offload_flow_rule (tc_flow_cmd); +struct flow_dissector *dissector = rule->match.dissector;/* KEY_CONTROL and KEY_BASIC are needed for forming a meaningful key */ if ((dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_CONTROL)) == 0 ||
@@ -198,140 +192,120 @@ static int bnxt_tc_parse_flow(struct bnxt *bp,return -EOPNOTSUPP ; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_BASIC )) { -struct flow_dissector_key_basic *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_BASIC ); -struct flow_dissector_key_basic *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_BASIC ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_BASIC )) { +struct flow_match_basic match; - flow->l2_key.ether_type = key->n_proto; - flow->l2_mask.ether_type = mask->n_proto; +flow_rule_match_basic (rule, &match); + flow->l2_key.ether_type = match.key->n_proto; + flow->l2_mask.ether_type = match.mask->n_proto; -if (key->n_proto ==htons (ETH_P_IP ) || - key->n_proto ==htons (ETH_P_IPV6 )) { - flow->l4_key.ip_proto = key->ip_proto; - flow->l4_mask.ip_proto = mask->ip_proto; +if (match.key->n_proto ==htons (ETH_P_IP ) || + match.key->n_proto ==htons (ETH_P_IPV6 )) { + flow->l4_key.ip_proto = match.key->ip_proto; + flow->l4_mask.ip_proto = match.mask->ip_proto; } } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_ETH_ADDRS )) { -struct flow_dissector_key_eth_addrs *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_ETH_ADDRS ); -struct flow_dissector_key_eth_addrs *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_ETH_ADDRS ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ETH_ADDRS )) { +struct flow_match_eth_addrs match; +flow_rule_match_eth_addrs (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_ETH_ADDRS ; -ether_addr_copy (flow->l2_key.dmac, key->dst); -ether_addr_copy (flow->l2_mask.dmac, mask->dst); -ether_addr_copy (flow->l2_key.smac, key->src); -ether_addr_copy (flow->l2_mask.smac, mask->src); +ether_addr_copy (flow->l2_key.dmac, match.key->dst); +ether_addr_copy (flow->l2_mask.dmac, match.mask->dst); +ether_addr_copy (flow->l2_key.smac, match.key->src); +ether_addr_copy (flow->l2_mask.smac, match.mask->src); } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_VLAN )) { -struct flow_dissector_key_vlan *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_VLAN ); -struct flow_dissector_key_vlan *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_VLAN ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_VLAN )) { +struct flow_match_vlan match; +flow_rule_match_vlan (rule, &match); flow->l2_key.inner_vlan_tci = -cpu_to_be16 (VLAN_TCI (key->vlan_id, key->vlan_priority)); +cpu_to_be16 (VLAN_TCI (match.key->vlan_id, + match.key->vlan_priority)); flow->l2_mask.inner_vlan_tci = -cpu_to_be16 ((VLAN_TCI (mask->vlan_id, mask->vlan_priority))); +cpu_to_be16 ((VLAN_TCI (match.mask->vlan_id, + match.mask->vlan_priority))); flow->l2_key.inner_vlan_tpid =htons (ETH_P_8021Q ); flow->l2_mask.inner_vlan_tpid =htons (0xffff ); flow->l2_key.num_vlans =1 ; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_IPV4_ADDRS )) { -struct flow_dissector_key_ipv4_addrs *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_IPV4_ADDRS ); -struct flow_dissector_key_ipv4_addrs *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_IPV4_ADDRS ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_IPV4_ADDRS )) { +struct flow_match_ipv4_addrs match; +flow_rule_match_ipv4_addrs (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_IPV4_ADDRS ; - flow->l3_key.ipv4.daddr.s_addr = key->dst; - flow->l3_mask.ipv4.daddr.s_addr = mask->dst; - flow->l3_key.ipv4.saddr.s_addr = key->src; - flow->l3_mask.ipv4.saddr.s_addr = mask->src; - }else if (dissector_uses_key (dissector, -FLOW_DISSECTOR_KEY_IPV6_ADDRS )) { -struct flow_dissector_key_ipv6_addrs *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_IPV6_ADDRS ); -struct flow_dissector_key_ipv6_addrs *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_IPV6_ADDRS ); - + flow->l3_key.ipv4.daddr.s_addr = match.key->dst; + flow->l3_mask.ipv4.daddr.s_addr = match.mask->dst; + flow->l3_key.ipv4.saddr.s_addr = match.key->src; + flow->l3_mask.ipv4.saddr.s_addr = match.mask->src; + }else if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_IPV6_ADDRS )) { +struct flow_match_ipv6_addrs match; + +flow_rule_match_ipv6_addrs (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_IPV6_ADDRS ; - flow->l3_key.ipv6.daddr = key->dst; - flow->l3_mask.ipv6.daddr = mask->dst; - flow->l3_key.ipv6.saddr = key->src; - flow->l3_mask.ipv6.saddr = mask->src; + flow->l3_key.ipv6.daddr = match.key->dst; + flow->l3_mask.ipv6.daddr = match.mask->dst; + flow->l3_key.ipv6.saddr = match.key->src; + flow->l3_mask.ipv6.saddr = match.mask->src; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_PORTS )) { -struct flow_dissector_key_ports *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_PORTS ); -struct flow_dissector_key_ports *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_PORTS ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_PORTS )) { +struct flow_match_ports match; +flow_rule_match_ports (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_PORTS ; - flow->l4_key.ports.dport = key->dst; - flow->l4_mask.ports.dport = mask->dst; - flow->l4_key.ports.sport = key->src; - flow->l4_mask.ports.sport = mask->src; + flow->l4_key.ports.dport = match.key->dst; + flow->l4_mask.ports.dport = match.mask->dst; + flow->l4_key.ports.sport = match.key->src; + flow->l4_mask.ports.sport = match.mask->src; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_ICMP )) { -struct flow_dissector_key_icmp *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_ICMP ); -struct flow_dissector_key_icmp *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_ICMP ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ICMP )) { +struct flow_match_icmp match; +flow_rule_match_icmp (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_ICMP ; - flow->l4_key.icmp.type = key->type; - flow->l4_key.icmp.code = key->code; - flow->l4_mask.icmp.type = mask->type; - flow->l4_mask.icmp.code = mask->code; + flow->l4_key.icmp.type = match.key->type; + flow->l4_key.icmp.code = match.key->code; + flow->l4_mask.icmp.type = match.mask->type; + flow->l4_mask.icmp.code = match.mask->code; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS )) { -struct flow_dissector_key_ipv4_addrs *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS ); -struct flow_dissector_key_ipv4_addrs *mask = -GET_MASK (tc_flow_cmd, -FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS )) { +struct flow_match_ipv4_addrs match; +flow_rule_match_enc_ipv4_addrs (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_TUNL_IPV4_ADDRS ; - flow->tun_key.u.ipv4.dst = key->dst; - flow->tun_mask.u.ipv4.dst = mask->dst; - flow->tun_key.u.ipv4.src = key->src; - flow->tun_mask.u.ipv4.src = mask->src; - }else if (dissector_uses_key (dissector, + flow->tun_key.u.ipv4.dst = match.key->dst; + flow->tun_mask.u.ipv4.dst = match.mask->dst; + flow->tun_key.u.ipv4.src = match.key->src; + flow->tun_mask.u.ipv4.src = match.mask->src; + }else if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS )) {return -EOPNOTSUPP ; } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_ENC_KEYID )) { -struct flow_dissector_key_keyid *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_ENC_KEYID ); -struct flow_dissector_key_keyid *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_ENC_KEYID ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ENC_KEYID )) { +struct flow_match_enc_keyid match; +flow_rule_match_enc_keyid (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_TUNL_ID ; - flow->tun_key.tun_id =key32_to_tunnel_id (key->keyid); - flow->tun_mask.tun_id =key32_to_tunnel_id (mask->keyid); + flow->tun_key.tun_id =key32_to_tunnel_id (match.key->keyid); + flow->tun_mask.tun_id =key32_to_tunnel_id (match.mask->keyid); } -if (dissector_uses_key (dissector,FLOW_DISSECTOR_KEY_ENC_PORTS )) { -struct flow_dissector_key_ports *key = -GET_KEY (tc_flow_cmd,FLOW_DISSECTOR_KEY_ENC_PORTS ); -struct flow_dissector_key_ports *mask = -GET_MASK (tc_flow_cmd,FLOW_DISSECTOR_KEY_ENC_PORTS ); +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_ENC_PORTS )) { +struct flow_match_ports match; +flow_rule_match_enc_ports (rule, &match); flow->flags |=BNXT_TC_FLOW_FLAGS_TUNL_PORTS ; - flow->tun_key.tp_dst = key->dst; - flow->tun_mask.tp_dst = mask->dst; - flow->tun_key.tp_src = key->src; - flow->tun_mask.tp_src = mask->src; + flow->tun_key.tp_dst = match.key->dst; + flow->tun_mask.tp_dst = match.mask->dst; + flow->tun_key.tp_src = match.key->src; + flow->tun_mask.tp_src = match.mask->src; }return bnxt_tc_parse_actions (bp, &flow->actions, tc_flow_cmd->exts);
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +79 -115
268 lines not on this page · raw message
drivers/net/ethernet/intel/i40e/i40e_main.c +68 -110
292 lines not on this page · raw message
drivers/net/ethernet/intel/iavf/iavf_main.c +80 -115
336 lines not on this page · raw message
drivers/net/ethernet/intel/igb/igb_main.c +24 -40
111 lines not on this page · raw message
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +177 -243
661 lines not on this page · raw message
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c +88 -114
322 lines not on this page · raw message
drivers/net/ethernet/netronome/nfp/flower/action.c +5 -6
@@ -587,6 +587,7 @@ static int nfp_fl_pedit(const struct tc_action *action, struct tc_cls_flower_offload *flow, char *nfp_action, int *a_len, u32 *csum_updated) { + struct flow_rule *rule = tc_cls_flower_offload_flow_rule(flow);struct nfp_fl_set_ipv6_addr set_ip6_dst, set_ip6_src;struct nfp_fl_set_ipv6_tc_hl_fl set_ip6_tc_hl_fl;struct nfp_fl_set_ip4_ttl_tos set_ip_ttl_tos;
@@ -643,13 +644,11 @@ nfp_fl_pedit(const struct tc_action *action, struct tc_cls_flower_offload *flow,return err; } -if (dissector_uses_key (flow->dissector,FLOW_DISSECTOR_KEY_BASIC )) { -struct flow_dissector_key_basic *basic; +if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_BASIC )) { +struct flow_match_basic match; - basic =skb_flow_dissector_target (flow->dissector, -FLOW_DISSECTOR_KEY_BASIC , - flow->key); - ip_proto = basic->ip_proto; +flow_rule_match_basic (rule, &match); + ip_proto = match.key->ip_proto; }if (set_eth.head.len_lw) {
drivers/net/ethernet/netronome/nfp/flower/match.c +209 -208
549 lines not on this page · raw message
drivers/net/ethernet/netronome/nfp/flower/offload.c +55 -90
205 lines not on this page · raw message
drivers/net/ethernet/qlogic/qede/qede_filter.c +36 -49
85 lines not on this page · raw message
include/net/flow_offload.h new file +115 -0
115 lines not on this page · raw message
net/core/flow_offload.c new file +143 -0
143 lines not on this page · raw message
net/sched/cls_flower.c +34 -13
47 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.11.0
Part of the diff is not shown here. View the raw message.
Re: [PATCH net-next,v5 01/12] flow_offload: add flow_rule and flow_match structures and use them
Quoted 12 lines · Thu, Dec 06, 2018 at 11:39:51PM CET, [email protected] wrote:
This patch wraps the dissector key and mask - that flower uses to represent the matching side - around the
flow_matchstructure.To avoid a follow up patch that would edit the same LoCs in the drivers, this patch also wraps this new flow match structure around the flow rule object. This new structure will also contain the flow actions in follow up patches.
This introduces two new interfaces:
bool
flow_rule_match_key(rule, dissector_id)
Quoted 8 lines
that returns true if a given matching key is set on, and:
flow_rule_match_XYZ(rule, &match);To fetch the matching side XYZ into the match container structure, to retrieve the key and the mask with one single call.
Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 2/12 net/mlx5e: support for two independent packet edit actions
In reply to Pablo Neira AyusoThis patch adds pedit_headers_action structure to store the result of parsing tc pedit actions. Then, it calls alloc_tc_pedit_action() to populate the mlx5e hardware intermediate representation once all actions have been parsed.
This patch comes in preparation for the new flow_action infrastructure, where each packet mangling comes in an separated action, ie. not packed as in tc pedit.
---
v5: rebase on top of net-next head.
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 81 ++++++++++++++++++------- 1 file changed, 59 insertions(+), 22 deletions(-)
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +59 -22
@@ -1751,6 +1751,12 @@ struct pedit_headers {struct udphdr udp; }; +struct pedit_headers_action { +struct pedit_headers vals; +struct pedit_headers masks; +u32 pedits; +}; +static int pedit_header_offsets[] = { [TCA_PEDIT_KEY_EX_HDR_TYPE_ETH ] = offsetof(struct pedit_headers , eth), [TCA_PEDIT_KEY_EX_HDR_TYPE_IP4 ] = offsetof(struct pedit_headers , ip4),
@@ -1762,16 +1768,15 @@ static int pedit_header_offsets[] = {#define pedit_header (_ph, _htype) ((void *)(_ph) + pedit_header_offsets[_htype])static int set_pedit_val (u8 hdr_type,u32 mask,u32 val,u32 offset, -struct pedit_headers *masks, -struct pedit_headers *vals) +struct pedit_headers_action *hdrs) {u32 *curr_pmask, *curr_pval;if (hdr_type >= __PEDIT_HDR_TYPE_MAX) goto out_err; - curr_pmask = (u32 *)(pedit_header (masks, hdr_type) + offset); - curr_pval = (u32 *)(pedit_header (vals, hdr_type) + offset); + curr_pmask = (u32 *)(pedit_header (&hdrs->masks, hdr_type) + offset); + curr_pval = (u32 *)(pedit_header (&hdrs->vals, hdr_type) + offset);if (*curr_pmask & mask)/* disallow acting twice on the same location */ goto out_err;
@@ -1827,8 +1832,7 @@ static struct mlx5_fields fields[] = {* max from the SW pedit action. On success, it says how many HW actions were * actually parsed. */ -static int offload_pedit_fields (struct pedit_headers *masks, -struct pedit_headers *vals, +static int offload_pedit_fields (struct pedit_headers_action *hdrs,struct mlx5e_tc_flow_parse_attr *parse_attr,struct netlink_ext_ack *extack) {
@@ -1843,10 +1847,10 @@ static int offload_pedit_fields(struct pedit_headers *masks,__be16 mask_be16;void *action; - set_masks = &masks[TCA_PEDIT_KEY_EX_CMD_SET ]; - add_masks = &masks[TCA_PEDIT_KEY_EX_CMD_ADD ]; - set_vals = &vals[TCA_PEDIT_KEY_EX_CMD_SET ]; - add_vals = &vals[TCA_PEDIT_KEY_EX_CMD_ADD ]; + set_masks = &hdrs[TCA_PEDIT_KEY_EX_CMD_SET ].masks; + add_masks = &hdrs[TCA_PEDIT_KEY_EX_CMD_ADD ].masks; + set_vals = &hdrs[TCA_PEDIT_KEY_EX_CMD_SET ].vals; + add_vals = &hdrs[TCA_PEDIT_KEY_EX_CMD_ADD ].vals; action_size =MLX5_UN_SZ_BYTES (set_action_in_add_action_in_auto); action = parse_attr->mod_hdr_actions;
@@ -1942,12 +1946,14 @@ static int offload_pedit_fields(struct pedit_headers *masks, }static int alloc_mod_hdr_actions (struct mlx5e_priv *priv, -const struct tc_action *a,int namespace, +struct pedit_headers_action *hdrs, +int namespace,struct mlx5e_tc_flow_parse_attr *parse_attr) {int nkeys, action_size, max_actions; - nkeys =tcf_pedit_nkeys (a); + nkeys = hdrs[TCA_PEDIT_KEY_EX_CMD_SET ].pedits + + hdrs[TCA_PEDIT_KEY_EX_CMD_ADD ].pedits; action_size =MLX5_UN_SZ_BYTES (set_action_in_add_action_in_auto);if (namespace ==MLX5_FLOW_NAMESPACE_FDB )/* FDB offloading */
@@ -1971,18 +1977,15 @@ static const struct pedit_headers zero_masks = {};static int parse_tc_pedit_action (struct mlx5e_priv *priv,const struct tc_action *a,int namespace,struct mlx5e_tc_flow_parse_attr *parse_attr, +struct pedit_headers_action *hdrs,struct netlink_ext_ack *extack) { -struct pedit_headers masks[__PEDIT_CMD_MAX], vals[__PEDIT_CMD_MAX], *cmd_masks;int nkeys, i, err = -EOPNOTSUPP ;u32 mask, val, offset;u8 cmd, htype; nkeys =tcf_pedit_nkeys (a); -memset (masks,0 ,sizeof (struct pedit_headers ) * __PEDIT_CMD_MAX); -memset (vals,0 ,sizeof (struct pedit_headers ) * __PEDIT_CMD_MAX); -for (i =0 ; i < nkeys; i++) { htype =tcf_pedit_htype (a, i); cmd =tcf_pedit_cmd (a, i);
@@ -2003,21 +2006,37 @@ static int parse_tc_pedit_action(struct mlx5e_priv *priv, val =tcf_pedit_val (a, i); offset =tcf_pedit_offset (a, i); - err =set_pedit_val (htype, ~mask, val, offset, &masks[cmd], &vals[cmd]); + err =set_pedit_val (htype, ~mask, val, offset, &hdrs[cmd]);if (err) goto out_err; + + hdrs[cmd].pedits++; } - err =alloc_mod_hdr_actions (priv, a, namespace, parse_attr); +return 0 ; +out_err: +return err; +} + +static int alloc_tc_pedit_action (struct mlx5e_priv *priv,int namespace, +struct mlx5e_tc_flow_parse_attr *parse_attr, +struct pedit_headers_action *hdrs, +struct netlink_ext_ack *extack) +{ +struct pedit_headers *cmd_masks; +int err; +u8 cmd; + + err =alloc_mod_hdr_actions (priv, hdrs, namespace, parse_attr);if (err) goto out_err; - err =offload_pedit_fields (masks, vals, parse_attr, extack); + err =offload_pedit_fields (hdrs, parse_attr, extack);if (err <0 ) goto out_dealloc_parsed_actions;for (cmd =0 ; cmd < __PEDIT_CMD_MAX; cmd++) { - cmd_masks = &masks[cmd]; + cmd_masks = &hdrs[cmd].masks;if (memcmp (cmd_masks, &zero_masks,sizeof (zero_masks))) {NL_SET_ERR_MSG_MOD (extack,"attempt to offload an unsupported field" );
@@ -2159,6 +2178,7 @@ static int parse_tc_nic_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,struct mlx5e_tc_flow *flow, struct netlink_ext_ack *extack) { + struct pedit_headers_action hdrs[__PEDIT_CMD_MAX] = {};struct mlx5_nic_flow_attr *attr = flow->nic_attr;const struct tc_action *a;LIST_HEAD (actions);
@@ -2181,7 +2201,7 @@ static int parse_tc_nic_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,if (is_tcf_pedit (a)) { err =parse_tc_pedit_action (priv, a,MLX5_FLOW_NAMESPACE_KERNEL , - parse_attr, extack); + parse_attr, hdrs, extack);if (err)return err;
@@ -2235,6 +2255,14 @@ static int parse_tc_nic_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,return -EINVAL ; } +if (hdrs[TCA_PEDIT_KEY_EX_CMD_SET ].pedits || + hdrs[TCA_PEDIT_KEY_EX_CMD_ADD ].pedits) { + err =alloc_tc_pedit_action (priv,MLX5_FLOW_NAMESPACE_KERNEL , + parse_attr, hdrs, extack); +if (err) +return err; + } + attr->action = action;if (!actions_match_supported (priv, exts, parse_attr, flow, extack))return -EOPNOTSUPP ;
@@ -2781,6 +2809,7 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,struct mlx5e_tc_flow *flow, struct netlink_ext_ack *extack) { + struct pedit_headers_action hdrs[__PEDIT_CMD_MAX] = {};struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;struct mlx5_esw_flow_attr *attr = flow->esw_attr;struct mlx5e_rep_priv *rpriv = priv->ppriv;
@@ -2806,7 +2835,7 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,if (is_tcf_pedit (a)) { err =parse_tc_pedit_action (priv, a,MLX5_FLOW_NAMESPACE_FDB , - parse_attr, extack); + parse_attr, hdrs, extack);if (err)return err;
@@ -2912,6 +2941,14 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, struct tcf_exts *exts,return -EINVAL ; } +if (hdrs[TCA_PEDIT_KEY_EX_CMD_SET ].pedits || + hdrs[TCA_PEDIT_KEY_EX_CMD_ADD ].pedits) { + err =alloc_tc_pedit_action (priv,MLX5_FLOW_NAMESPACE_KERNEL , + parse_attr, hdrs, extack); +if (err) +return err; + } + attr->action = action;if (!actions_match_supported (priv, exts, parse_attr, flow, extack))return -EOPNOTSUPP ;
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 02/12] net/mlx5e: support for two independent packet edit actions
Quoted 10 lines · Thu, Dec 06, 2018 at 11:39:52PM CET, [email protected] wrote:
This patch adds
pedit_headers_actionstructure to store the result of parsing tc pedit actions. Then, it callsalloc_tc_pedit_action()to populate the mlx5e hardware intermediate representation once all actions have been parsed.This patch comes in preparation for the new
flow_actioninfrastructure, where each packet mangling comes in an separated action, ie. not packed as in tc pedit.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 3/12 flow_offload: add flow action infrastructure
In reply to Pablo Neira AyusoThis new infrastructure defines the nic actions that you can perform from existing network drivers. This infrastructure allows us to avoid a direct dependency with the native software TC action representation.
---
v5: rebase on top of net-next head.
include/net/flow_offload.h | 69 +++++++++++++++++++++++++++++++++++++++++++++- include/net/pkt_cls.h | 2 ++ net/core/flow_offload.c | 14 ++++++++-- net/sched/cls_api.c | 17 ++++++++++++ net/sched/cls_flower.c | 7 +++-- 5 files changed, 103 insertions(+), 6 deletions(-)
include/net/flow_offload.h +68 -1
@@ -100,11 +100,78 @@ void flow_rule_match_enc_keyid(const struct flow_rule *rule,void flow_rule_match_enc_opts (const struct flow_rule *rule,struct flow_match_enc_opts *out); +enum flow_action_id { +FLOW_ACTION_ACCEPT =0 , +FLOW_ACTION_DROP , +FLOW_ACTION_TRAP , +FLOW_ACTION_GOTO , +FLOW_ACTION_REDIRECT , +FLOW_ACTION_MIRRED , +FLOW_ACTION_VLAN_PUSH , +FLOW_ACTION_VLAN_POP , +FLOW_ACTION_VLAN_MANGLE , +FLOW_ACTION_TUNNEL_ENCAP , +FLOW_ACTION_TUNNEL_DECAP , +FLOW_ACTION_MANGLE , +FLOW_ACTION_ADD , +FLOW_ACTION_CSUM , +FLOW_ACTION_MARK , +}; + +/* This is mirroring enum pedit_header_type definition for easy mapping between +* tc pedit action. Legacy TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK is mapped to +* FLOW_ACT_MANGLE_UNSPEC, which is supported by no driver. +*/ +enum flow_action_mangle_base { +FLOW_ACT_MANGLE_UNSPEC =0 , +FLOW_ACT_MANGLE_HDR_TYPE_ETH , +FLOW_ACT_MANGLE_HDR_TYPE_IP4 , +FLOW_ACT_MANGLE_HDR_TYPE_IP6 , +FLOW_ACT_MANGLE_HDR_TYPE_TCP , +FLOW_ACT_MANGLE_HDR_TYPE_UDP , +}; + +struct flow_action_entry { +enum flow_action_id id; +union { +u32 chain_index;/* FLOW_ACTION_GOTO */ +struct net_device *dev;/* FLOW_ACTION_REDIRECT */ +struct {/* FLOW_ACTION_VLAN */ +u16 vid; +__be16 proto; +u8 prio; + } vlan; +struct {/* FLOW_ACTION_PACKET_EDIT */ +enum flow_action_mangle_base htype; +u32 offset; +u32 mask; +u32 val; + } mangle; +const struct ip_tunnel_info *tunnel;/* FLOW_ACTION_TUNNEL_ENCAP */ +u32 csum_flags;/* FLOW_ACTION_CSUM */ +u32 mark;/* FLOW_ACTION_MARK */ + }; +}; + +struct flow_action { +unsigned int num_entries; +struct flow_action_entry entries[0 ]; +}; + +static inline bool flow_action_has_entries (const struct flow_action *action) +{ +return action->num_entries; +} + +#define flow_action_for_each (__i, __act, __actions) \ + for (__i = 0, __act = &(__actions)->entries[0]; __i < (__actions)->num_entries; __act = &(__actions)->entries[__i++]) +struct flow_rule {struct flow_match match; +struct flow_action action; }; -struct flow_rule *flow_rule_alloc (void ); +struct flow_rule *flow_rule_alloc (unsigned int num_actions);static inline bool flow_rule_match_key (const struct flow_rule *rule,enum flow_dissector_key_id key)
include/net/pkt_cls.h +2 -0
@@ -620,6 +620,8 @@ tcf_match_indev(struct sk_buff *skb, int ifindex) }#endif /* CONFIG_NET_CLS_IND */ +unsigned int tcf_exts_num_actions (struct tcf_exts *exts); +int tc_setup_cb_call (struct tcf_block *block,struct tcf_exts *exts,enum tc_setup_type type,void *type_data,bool err_stop);
net/core/flow_offload.c +12 -2
@@ -3,9 +3,19 @@#include <linux/slab.h> #include <net/flow_offload.h> -struct flow_rule *flow_rule_alloc (void ) +struct flow_rule *flow_rule_alloc (unsigned int num_actions) { -return kzalloc (sizeof (struct flow_rule ),GFP_KERNEL ); +struct flow_rule *rule; + + rule =kzalloc (sizeof (struct flow_rule ) + +sizeof (struct flow_action_entry ) * num_actions, +GFP_KERNEL ); +if (!rule) +return NULL ; + + rule->action.num_entries = num_actions; + +return rule; }EXPORT_SYMBOL (flow_rule_alloc);
net/sched/cls_api.c +17 -0
@@ -31,6 +31,7 @@#include <net/netlink.h> #include <net/pkt_sched.h> #include <net/pkt_cls.h> +#include <net/tc_act/tc_pedit.h> extern const struct nla_policy rtm_tca_policy[TCA_MAX +1 ];
@@ -2567,6 +2568,22 @@ int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts, }EXPORT_SYMBOL (tc_setup_cb_call); +unsigned int tcf_exts_num_actions (struct tcf_exts *exts) +{ +unsigned int num_acts =0 ; +struct tc_action *act; +int i; + +tcf_exts_for_each_action (i, act, exts) { +if (is_tcf_pedit (act)) + num_acts +=tcf_pedit_nkeys (act); +else + num_acts++; + } +return num_acts; +} +EXPORT_SYMBOL (tcf_exts_num_actions); +static __net_init int tcf_net_init (struct net *net) {struct tcf_net *tn =net_generic (net, tcf_net_id);
net/sched/cls_flower.c +4 -3
@@ -382,7 +382,7 @@ static int fl_hw_replace_filter(struct tcf_proto *tp,bool skip_sw =tc_skip_sw (f->flags);int err; - cls_flower.rule =flow_rule_alloc (); + cls_flower.rule =flow_rule_alloc (tcf_exts_num_actions (&f->exts));if (!cls_flower.rule)return -ENOMEM ;
@@ -1467,7 +1467,8 @@ static int fl_reoffload(struct tcf_proto *tp, bool add, tc_setup_cb_t *cb,if (tc_skip_hw (f->flags))continue ; - cls_flower.rule =flow_rule_alloc (); + cls_flower.rule = +flow_rule_alloc (tcf_exts_num_actions (&f->exts));if (!cls_flower.rule)return -ENOMEM ;
@@ -1506,7 +1507,7 @@ static int fl_hw_create_tmplt(struct tcf_chain *chain,struct tcf_block *block = chain->block;struct tcf_exts dummy_exts = {0 , }; - cls_flower.rule =flow_rule_alloc (); + cls_flower.rule =flow_rule_alloc (0 );if (!cls_flower.rule)return -ENOMEM ;
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 03/12] flow_offload: add flow action infrastructure
Quoted 5 lines · Thu, Dec 06, 2018 at 11:39:53PM CET, [email protected] wrote:
This new infrastructure defines the nic actions that you can perform from existing network drivers. This infrastructure allows us to avoid a direct dependency with the native software TC action representation.
Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 4/12 cls_api: add translator to flow_action representation
In reply to Pablo Neira AyusoThis patch implements a new function to translate from native TC action to the new flow_action representation. Moreover, this patch also updates cls_flower to use this new function.
---
v5: rebase on top of net-next head.
include/net/pkt_cls.h | 3 ++ net/sched/cls_api.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++ net/sched/cls_flower.c | 14 +++++++ 3 files changed, 116 insertions(+)
include/net/pkt_cls.h +3 -0
@@ -622,6 +622,9 @@ tcf_match_indev(struct sk_buff *skb, int ifindex)unsigned int tcf_exts_num_actions (struct tcf_exts *exts); +int tc_setup_flow_action (struct flow_action *flow_action, +const struct tcf_exts *exts); +int tc_setup_cb_call (struct tcf_block *block,struct tcf_exts *exts,enum tc_setup_type type,void *type_data,bool err_stop);
net/sched/cls_api.c +99 -0
111 lines not on this page · raw message
net/sched/cls_flower.c +14 -0
@@ -395,6 +395,12 @@ static int fl_hw_replace_filter(struct tcf_proto *tp, cls_flower.exts = &f->exts; cls_flower.classid = f->res.classid; + err =tc_setup_flow_action (&cls_flower.rule->action, &f->exts); +if (err) { +kfree (cls_flower.rule); +return err; + } + err =tc_setup_cb_call (block, &f->exts,TC_SETUP_CLSFLOWER , &cls_flower, skip_sw);kfree (cls_flower.rule);
@@ -1481,6 +1487,14 @@ static int fl_reoffload(struct tcf_proto *tp, bool add, tc_setup_cb_t *cb, cls_flower.rule->match.mask = &mask->key; cls_flower.rule->match.key = &f->mkey; cls_flower.exts = &f->exts; + + err =tc_setup_flow_action (&cls_flower.rule->action, + &f->exts); +if (err) { +kfree (cls_flower.rule); +return err; + } + cls_flower.classid = f->res.classid; err =cb (TC_SETUP_CLSFLOWER , &cls_flower, cb_priv);
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 04/12] cls_api: add translator to flow_action representation
Quoted 5 lines · Thu, Dec 06, 2018 at 11:39:54PM CET, [email protected] wrote:
This patch implements a new function to translate from native TC action to the new
flow_actionrepresentation. Moreover, this patch also updatescls_flowerto use this new function.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 5/12 flow_offload: add statistics retrieval infrastructure and use it
In reply to Pablo Neira AyusoThis patch provides the flow_stats structure that acts as container for tc_cls_flower_offload, then we can use to restore the statistics on the existing TC actions. Hence, tcf_exts_stats_update() is not used from drivers anymore.
---
v5: Fix bytes and packet parameter swap in flow_stats_update() call,
reported by Venkat Duvvuru.
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c | 4 ++-- drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 6 +++--- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 2 +- drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c | 2 +- drivers/net/ethernet/netronome/nfp/flower/offload.c | 5 ++--- include/net/flow_offload.h | 14 ++++++++++++++ include/net/pkt_cls.h | 1 + net/sched/cls_flower.c | 4 ++++ 8 files changed, 28 insertions(+), 10 deletions(-)
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c +2 -2
@@ -1366,8 +1366,8 @@ static int bnxt_tc_get_flow_stats(struct bnxt *bp, lastused = flow->lastused;spin_unlock (&flow->stats_lock); -tcf_exts_stats_update (tc_flow_cmd->exts, stats.bytes, stats.packets, - lastused); +flow_stats_update (&tc_flow_cmd->stats, stats.bytes, stats.packets, + lastused);return 0 ; }
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +3 -3
@@ -807,9 +807,9 @@ int cxgb4_tc_flower_stats(struct net_device *dev,if (ofld_stats->packet_count != packets) {if (ofld_stats->prev_packet_count != packets) ofld_stats->last_used = jiffies; -tcf_exts_stats_update (cls->exts, bytes - ofld_stats->byte_count, - packets - ofld_stats->packet_count, - ofld_stats->last_used); +flow_stats_update (&cls->stats, bytes - ofld_stats->byte_count, + packets - ofld_stats->packet_count, + ofld_stats->last_used); ofld_stats->packet_count = packets; ofld_stats->byte_count = bytes;
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +1 -1
@@ -3227,7 +3227,7 @@ int mlx5e_stats_flower(struct mlx5e_priv *priv,mlx5_fc_query_cached (counter, &bytes, &packets, &lastuse); -tcf_exts_stats_update (f->exts, bytes, packets, lastuse); +flow_stats_update (&f->stats, bytes, packets, lastuse);return 0 ; }
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c +1 -1
@@ -460,7 +460,7 @@ int mlxsw_sp_flower_stats(struct mlxsw_sp *mlxsw_sp,if (err) goto err_rule_get_stats; -tcf_exts_stats_update (f->exts, bytes, packets, lastuse); +flow_stats_update (&f->stats, bytes, packets, lastuse);mlxsw_sp_acl_ruleset_put (mlxsw_sp, ruleset);return 0 ;
drivers/net/ethernet/netronome/nfp/flower/offload.c +2 -3
@@ -532,9 +532,8 @@ nfp_flower_get_stats(struct nfp_app *app, struct net_device *netdev, ctx_id =be32_to_cpu (nfp_flow->meta.host_ctx_id);spin_lock_bh (&priv->stats_lock); -tcf_exts_stats_update (flow->exts, priv->stats[ctx_id].bytes, - priv->stats[ctx_id].pkts, - priv->stats[ctx_id].used); +flow_stats_update (&flow->stats, priv->stats[ctx_id].bytes, + priv->stats[ctx_id].pkts, priv->stats[ctx_id].used); priv->stats[ctx_id].pkts =0 ; priv->stats[ctx_id].bytes =0 ;
include/net/flow_offload.h +14 -0
@@ -179,4 +179,18 @@ static inline bool flow_rule_match_key(const struct flow_rule *rule, return dissector_uses_key(rule->match.dissector, key); } +struct flow_stats { +u64 pkts; +u64 bytes; +u64 lastused; +}; + +static inline void flow_stats_update (struct flow_stats *flow_stats, +u64 bytes,u64 pkts,u64 lastused) +{ + flow_stats->pkts = pkts; + flow_stats->bytes = bytes; + flow_stats->lastused = lastused; +} +#endif /* _NET_FLOW_OFFLOAD_H */
include/net/pkt_cls.h +1 -0
@@ -767,6 +767,7 @@ struct tc_cls_flower_offload {enum tc_fl_command command;unsigned long cookie;struct flow_rule *rule; +struct flow_stats stats;struct tcf_exts *exts;u32 classid; };
net/sched/cls_flower.c +4 -0
@@ -432,6 +432,10 @@ static void fl_hw_update_stats(struct tcf_proto *tp, struct cls_fl_filter *f)tc_setup_cb_call (block, &f->exts,TC_SETUP_CLSFLOWER , &cls_flower, false); + +tcf_exts_stats_update (&f->exts, cls_flower.stats.bytes, + cls_flower.stats.pkts, + cls_flower.stats.lastused); } static bool __fl_delete(struct tcf_proto *tp, struct cls_fl_filter *f,
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 05/12] flow_offload: add statistics retrieval infrastructure and use it
Quoted 6 lines · Thu, Dec 06, 2018 at 11:39:55PM CET, [email protected] wrote:
This patch provides the
flow_statsstructure that acts as container fortc_cls_flower_offload, then we can use to restore the statistics on the existing TC actions. Hence,tcf_exts_stats_update()is not used from drivers anymore.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 6/12 drivers: net: use flow action infrastructure
In reply to Pablo Neira AyusoThis patch updates drivers to use the new flow action infrastructure.
---
v5: rebase on top of net-next head.
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c | 74 +++--- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 250 +++++++++---------- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 266 ++++++++++----------- drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c | 2 +- .../net/ethernet/mellanox/mlxsw/spectrum_flower.c | 54 +++-- drivers/net/ethernet/netronome/nfp/flower/action.c | 187 ++++++++------- drivers/net/ethernet/qlogic/qede/qede_filter.c | 12 +- 7 files changed, 418 insertions(+), 427 deletions(-)
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c +33 -41
@@ -61,9 +61,9 @@ static u16 bnxt_flow_get_dst_fid(struct bnxt *pf_bp, struct net_device *dev)static int bnxt_tc_parse_redir (struct bnxt *bp,struct bnxt_tc_actions *actions, -const struct tc_action *tc_act) +const struct flow_action_entry *act) { -struct net_device *dev =tcf_mirred_dev (tc_act); +struct net_device *dev = act->dev;if (!dev) {netdev_info (bp->dev,"no dev in mirred action" );
@@ -77,16 +77,16 @@ static int bnxt_tc_parse_redir(struct bnxt *bp,static int bnxt_tc_parse_vlan (struct bnxt *bp,struct bnxt_tc_actions *actions, -const struct tc_action *tc_act) +const struct flow_action_entry *act) { -switch (tcf_vlan_action (tc_act)) { -case TCA_VLAN_ACT_POP : +switch (act->id) { +case FLOW_ACTION_VLAN_POP : actions->flags |=BNXT_TC_ACTION_FLAG_POP_VLAN ;break ; -case TCA_VLAN_ACT_PUSH : +case FLOW_ACTION_VLAN_PUSH : actions->flags |=BNXT_TC_ACTION_FLAG_PUSH_VLAN ; - actions->push_vlan_tci =htons (tcf_vlan_push_vid (tc_act)); - actions->push_vlan_tpid =tcf_vlan_push_proto (tc_act); + actions->push_vlan_tci =htons (act->vlan.vid); + actions->push_vlan_tpid = act->vlan.proto;break ;default :return -EOPNOTSUPP ;
@@ -96,10 +96,10 @@ static int bnxt_tc_parse_vlan(struct bnxt *bp,static int bnxt_tc_parse_tunnel_set (struct bnxt *bp,struct bnxt_tc_actions *actions, -const struct tc_action *tc_act) +const struct flow_action_entry *act) { -struct ip_tunnel_info *tun_info =tcf_tunnel_info (tc_act); -struct ip_tunnel_key *tun_key = &tun_info->key; +const struct ip_tunnel_info *tun_info = act->tunnel; +const struct ip_tunnel_key *tun_key = &tun_info->key;if (ip_tunnel_info_af (tun_info) !=AF_INET ) {netdev_info (bp->dev,"only IPv4 tunnel-encap is supported" );
@@ -113,51 +113,43 @@ static int bnxt_tc_parse_tunnel_set(struct bnxt *bp,static int bnxt_tc_parse_actions (struct bnxt *bp,struct bnxt_tc_actions *actions, -struct tcf_exts *tc_exts) +struct flow_action *flow_action) { -const struct tc_action *tc_act; +struct flow_action_entry *act;int i, rc; -if (!tcf_exts_has_actions (tc_exts)) { +if (!flow_action_has_entries (flow_action)) {netdev_info (bp->dev,"no actions" );return -EINVAL ; } -tcf_exts_for_each_action (i, tc_act, tc_exts) { -/* Drop action */ -if (is_tcf_gact_shot (tc_act)) { +flow_action_for_each (i, act, flow_action) { +switch (act->id) { +case FLOW_ACTION_DROP : actions->flags |=BNXT_TC_ACTION_FLAG_DROP ;return 0 ;/* don't bother with other actions */ - } - -/* Redirect action */ -if (is_tcf_mirred_egress_redirect (tc_act)) { - rc =bnxt_tc_parse_redir (bp, actions, tc_act); +case FLOW_ACTION_REDIRECT : + rc =bnxt_tc_parse_redir (bp, actions, act);if (rc)return rc; -continue ; - } - -/* Push/pop VLAN */ -if (is_tcf_vlan (tc_act)) { - rc =bnxt_tc_parse_vlan (bp, actions, tc_act); +break ; +case FLOW_ACTION_VLAN_POP : +case FLOW_ACTION_VLAN_PUSH : +case FLOW_ACTION_VLAN_MANGLE : + rc =bnxt_tc_parse_vlan (bp, actions, act);if (rc)return rc; -continue ; - } - -/* Tunnel encap */ -if (is_tcf_tunnel_set (tc_act)) { - rc =bnxt_tc_parse_tunnel_set (bp, actions, tc_act); +break ; +case FLOW_ACTION_TUNNEL_ENCAP : + rc =bnxt_tc_parse_tunnel_set (bp, actions, act);if (rc)return rc; -continue ; - } - -/* Tunnel decap */ -if (is_tcf_tunnel_release (tc_act)) { +break ; +case FLOW_ACTION_TUNNEL_DECAP : actions->flags |=BNXT_TC_ACTION_FLAG_TUNNEL_DECAP ; -continue ; +break ; +default : +break ; } }
@@ -308,7 +300,7 @@ static int bnxt_tc_parse_flow(struct bnxt *bp, flow->tun_mask.tp_src = match.mask->src; } -return bnxt_tc_parse_actions (bp, &flow->actions, tc_flow_cmd->exts); +return bnxt_tc_parse_actions (bp, &flow->actions, &rule->action); }static int bnxt_hwrm_cfa_flow_free (struct bnxt *bp,__le16 flow_handle)
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +127 -123
371 lines not on this page · raw message
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +123 -143
503 lines not on this page · raw message
drivers/net/ethernet/mellanox/mlxsw/spectrum_acl.c +1 -1
@@ -579,7 +579,7 @@ int mlxsw_sp_acl_rulei_act_vlan(struct mlxsw_sp *mlxsw_sp, {u8 ethertype; -if (action ==TCA_VLAN_ACT_MODIFY ) { +if (action ==FLOW_ACTION_VLAN_MANGLE ) {switch (proto) {case ETH_P_8021Q : ethertype =0 ;
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c +33 -21
116 lines not on this page · raw message
drivers/net/ethernet/netronome/nfp/flower/action.c +95 -92
410 lines not on this page · raw message
drivers/net/ethernet/qlogic/qede/qede_filter.c +6 -6
@@ -2004,21 +2004,21 @@ int qede_get_arfs_filter_count(struct qede_dev *edev) }static int qede_parse_actions (struct qede_dev *edev, -struct tcf_exts *exts) +struct flow_action *flow_action) { +const struct flow_action_entry *act;int rc = -EINVAL , num_act =0 , i; -const struct tc_action *a;bool is_drop = false; -if (!tcf_exts_has_actions (exts)) { +if (!flow_action_has_entries (flow_action)) {DP_NOTICE (edev,"No tc actions received\n" );return rc; } -tcf_exts_for_each_action (i, a, exts) { +flow_action_for_each (i, act, flow_action) { num_act++; -if (is_tcf_gact_shot (a)) +if (act->id ==FLOW_ACTION_DROP ) is_drop = true; }
@@ -2235,7 +2235,7 @@ int qede_add_tc_flower_fltr(struct qede_dev *edev, __be16 proto, }/* parse tc actions and get the vf_id */ -if (qede_parse_actions (edev, f->exts)) +if (qede_parse_actions (edev, &f->rule->action)) goto unlock;if (qede_flow_find_fltr (edev, &t)) {
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 06/12] drivers: net: use flow action infrastructure
Quoted 3 lines · Thu, Dec 06, 2018 at 11:39:56PM CET, [email protected] wrote:
This patch updates drivers to use the new flow action infrastructure.
Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 7/12 cls_flower: don't expose TC actions to drivers anymore
In reply to Pablo Neira AyusoNow that drivers have been converted to use the flow action infrastructure, remove this field from the tc_cls_flower_offload structure.
---
v5: rebase on top of net-next head.
include/net/pkt_cls.h | 1 - net/sched/cls_flower.c | 5 ----- 2 files changed, 6 deletions(-)
include/net/pkt_cls.h +0 -1
@@ -768,7 +768,6 @@ struct tc_cls_flower_offload {unsigned long cookie;struct flow_rule *rule;struct flow_stats stats; -struct tcf_exts *exts;u32 classid; };
net/sched/cls_flower.c +0 -5
@@ -392,7 +392,6 @@ static int fl_hw_replace_filter(struct tcf_proto *tp, cls_flower.rule->match.dissector = &f->mask->dissector; cls_flower.rule->match.mask = &f->mask->key; cls_flower.rule->match.key = &f->mkey; - cls_flower.exts = &f->exts; cls_flower.classid = f->res.classid; err =tc_setup_flow_action (&cls_flower.rule->action, &f->exts);
@@ -427,7 +426,6 @@ static void fl_hw_update_stats(struct tcf_proto *tp, struct cls_fl_filter *f)tc_cls_common_offload_init (&cls_flower.common, tp, f->flags,NULL ); cls_flower.command =TC_CLSFLOWER_STATS ; cls_flower.cookie = (unsigned long ) f; - cls_flower.exts = &f->exts; cls_flower.classid = f->res.classid; tc_setup_cb_call(block, &f->exts, TC_SETUP_CLSFLOWER,
@@ -1490,7 +1488,6 @@ static int fl_reoffload(struct tcf_proto *tp, bool add, tc_setup_cb_t *cb, cls_flower.rule->match.dissector = &mask->dissector; cls_flower.rule->match.mask = &mask->key; cls_flower.rule->match.key = &f->mkey; - cls_flower.exts = &f->exts; err =tc_setup_flow_action (&cls_flower.rule->action, &f->exts);
@@ -1523,7 +1520,6 @@ static int fl_hw_create_tmplt(struct tcf_chain *chain, {struct tc_cls_flower_offload cls_flower = {};struct tcf_block *block = chain->block; -struct tcf_exts dummy_exts = {0 , }; cls_flower.rule =flow_rule_alloc (0 );if (!cls_flower.rule)
@@ -1535,7 +1531,6 @@ static int fl_hw_create_tmplt(struct tcf_chain *chain, cls_flower.rule->match.dissector = &tmplt->dissector; cls_flower.rule->match.mask = &tmplt->mask; cls_flower.rule->match.key = &tmplt->dummy_key; - cls_flower.exts = &dummy_exts;/* We don't care if driver (any of them) fails to handle this * call. It serves just as a hint for it.
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 07/12] cls_flower: don't expose TC actions to drivers anymore
Quoted 5 lines · Thu, Dec 06, 2018 at 11:39:57PM CET, [email protected] wrote:
Now that drivers have been converted to use the flow action infrastructure, remove this field from the
tc_cls_flower_offloadstructure.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 8/12 flow_offload: add wake-up-on-lan and queue to flow_action
In reply to Pablo Neira AyusoThese actions need to be added to support the ethtool_rx_flow interface. The queue action includes a field to specify the RSS context, that is set via FLOW_RSS flow type flag and the rss_context field in struct ethtool_rxnfc, plus the corresponding queue index. FLOW_RSS implies that rss_context is non-zero, therefore, queue.ctx == 0 means that FLOW_RSS was not set.
---
v5: add queue structure and context field, per Michal Kubecek.
include/net/flow_offload.h | 6 ++++++ 1 file changed, 6 insertions(+)
include/net/flow_offload.h +6 -0
@@ -116,6 +116,8 @@ enum flow_action_id {FLOW_ACTION_ADD ,FLOW_ACTION_CSUM ,FLOW_ACTION_MARK , +FLOW_ACTION_WAKE , + FLOW_ACTION_QUEUE, };/* This is mirroring enum pedit_header_type definition for easy mapping between
@@ -150,6 +152,10 @@ struct flow_action_entry {const struct ip_tunnel_info *tunnel;/* FLOW_ACTION_TUNNEL_ENCAP */ u32 csum_flags;/* FLOW_ACTION_CSUM */ u32 mark;/* FLOW_ACTION_MARK */ +struct {/* FLOW_ACTION_QUEUE */ +u32 ctx; +u32 index; + } queue; }; };
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 08/12] flow_offload: add wake-up-on-lan and queue to flow_action
Quoted 8 lines · Thu, Dec 06, 2018 at 11:39:58PM CET, [email protected] wrote:
These actions need to be added to support the
ethtool_rx_flowinterface. The queue action includes a field to specify the RSS context, that is set viaFLOW_RSSflow type flag and therss_contextfield in structethtool_rxnfc, plus the corresponding queue index.FLOW_RSSimplies thatrss_contextis non-zero, therefore, queue.ctx == 0 means thatFLOW_RSSwas not set.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 9/12 ethtool: add ethtool_rx_flow_spec to flow_rule structure translator
In reply to Pablo Neira AyusoThis patch adds a function to translate the ethtool_rx_flow_spec structure to the flow_rule representation.
This allows us to reuse code from the driver side given that both flower and ethtool_rx_flow interfaces use the same representation.
This patch also includes support for the flow type flags FLOW_EXT, FLOW_MAC_EXT and FLOW_RSS.
The ethtool_rx_flow_spec_input wrapper structure is used to convey the rss_context field, that is away from the ethtool_rx_flow_spec structure, and the ethtool_rx_flow_spec structure.
---
v5: support for FLOW_RSS flowtype flag and set rss context in queue action.
Suggested by Michal Kubecek.
include/linux/ethtool.h | 15 +++ net/core/ethtool.c | 240 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 255 insertions(+)
include/linux/ethtool.h +15 -0
@@ -400,4 +400,19 @@ struct ethtool_ops {void (*get_ethtool_phy_stats)(struct net_device *, struct ethtool_stats *, u64 *); }; + +struct ethtool_rx_flow_rule { +struct flow_rule *rule; +unsigned long priv[0 ]; +}; + +struct ethtool_rx_flow_spec_input { +const struct ethtool_rx_flow_spec *fs; +u32 rss_ctx; +}; + +struct ethtool_rx_flow_rule * +ethtool_rx_flow_rule_create (const struct ethtool_rx_flow_spec_input *input); +void ethtool_rx_flow_rule_destroy (struct ethtool_rx_flow_rule *rule); +#endif /* _LINUX_ETHTOOL_H */
net/core/ethtool.c +240 -0
249 lines not on this page · raw message
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 09/12] ethtool: add ethtool_rx_flow_spec to flow_rule structure translator
Quoted 6 lines · Thu, Dec 06, 2018 at 11:39:59PM CET, [email protected] wrote:
This patch adds a function to translate the
ethtool_rx_flow_specstructure to theflow_rulerepresentation.This allows us to reuse code from the driver side given that both flower and
ethtool_rx_flowinterfaces use the same representation.
Quoted 8 lines
This patch also includes support for the flow type flags
FLOW_EXT,FLOW_MAC_EXTandFLOW_RSS.The
ethtool_rx_flow_spec_inputwrapper structure is used to convey therss_contextfield, that is away from theethtool_rx_flow_specstructure, and theethtool_rx_flow_specstructure.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 10/12 dsa: bcm_sf2: use flow_rule infrastructure
In reply to Pablo Neira AyusoUpdate this driver to use the flow_rule infrastructure, hence we can use the same code to populate hardware IR from ethtool_rx_flow and the cls_flower interfaces.
---
v5: rebase on top of net-next head.
drivers/net/dsa/bcm_sf2_cfp.c | 102 +++++++++++++++++++++++++++--------------- 1 file changed, 67 insertions(+), 35 deletions(-)
drivers/net/dsa/bcm_sf2_cfp.c +67 -35
@@ -16,6 +16,7 @@#include <linux/netdevice.h> #include <net/dsa.h> #include <linux/bitmap.h> +#include <net/flow_offload.h> #include "bcm_sf2.h" #include "bcm_sf2_regs.h"
@@ -257,7 +258,8 @@ static int bcm_sf2_cfp_act_pol_set(struct bcm_sf2_priv *priv, }static void bcm_sf2_cfp_slice_ipv4 (struct bcm_sf2_priv *priv, -struct ethtool_tcpip4_spec *v4_spec, +struct flow_dissector_key_ipv4_addrs *addrs, +struct flow_dissector_key_ports *ports,unsigned int slice_num,bool mask) {
@@ -278,7 +280,7 @@ static void bcm_sf2_cfp_slice_ipv4(struct bcm_sf2_priv *priv,* UDF_n_A6 [23:8] * UDF_n_A5 [7:0] */ - reg =be16_to_cpu (v4_spec->pdst) >>8 ; + reg =be16_to_cpu (ports->dst) >>8 ;if (mask) offset =CORE_CFP_MASK_PORT (3 );else
@@ -289,9 +291,9 @@ static void bcm_sf2_cfp_slice_ipv4(struct bcm_sf2_priv *priv,* UDF_n_A4 [23:8] * UDF_n_A3 [7:0] */ - reg = (be16_to_cpu (v4_spec->pdst) &0xff ) <<24 | - (u32 )be16_to_cpu (v4_spec->psrc) <<8 | - (be32_to_cpu (v4_spec->ip4dst) &0x0000ff00 ) >>8 ; + reg = (be16_to_cpu (ports->dst) &0xff ) <<24 | + (u32 )be16_to_cpu (ports->src) <<8 | + (be32_to_cpu (addrs->dst) &0x0000ff00 ) >>8 ;if (mask) offset =CORE_CFP_MASK_PORT (2 );else
@@ -302,9 +304,9 @@ static void bcm_sf2_cfp_slice_ipv4(struct bcm_sf2_priv *priv,* UDF_n_A2 [23:8] * UDF_n_A1 [7:0] */ - reg = (u32)(be32_to_cpu (v4_spec->ip4dst) &0xff ) <<24 | - (u32)(be32_to_cpu (v4_spec->ip4dst) >>16 ) <<8 | - (be32_to_cpu (v4_spec->ip4src) &0x0000ff00 ) >>8 ; + reg = (u32)(be32_to_cpu (addrs->dst) &0xff ) <<24 | + (u32)(be32_to_cpu (addrs->dst) >>16 ) <<8 | + (be32_to_cpu (addrs->src) &0x0000ff00 ) >>8 ;if (mask) offset =CORE_CFP_MASK_PORT (1 );else
@@ -317,8 +319,8 @@ static void bcm_sf2_cfp_slice_ipv4(struct bcm_sf2_priv *priv,* Slice ID [3:2] * Slice valid [1:0] */ - reg = (u32)(be32_to_cpu (v4_spec->ip4src) &0xff ) <<24 | - (u32)(be32_to_cpu (v4_spec->ip4src) >>16 ) <<8 | + reg = (u32)(be32_to_cpu (addrs->src) &0xff ) <<24 | + (u32)(be32_to_cpu (addrs->src) >>16 ) <<8 |SLICE_NUM (slice_num) |SLICE_VALID ;if (mask) offset =CORE_CFP_MASK_PORT (0 );
@@ -332,9 +334,13 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port,unsigned int queue_num, struct ethtool_rx_flow_spec *fs) { - struct ethtool_tcpip4_spec *v4_spec, *v4_m_spec; + struct ethtool_rx_flow_spec_input input = {};const struct cfp_udf_layout *layout;unsigned int slice_num, rule_index; +struct ethtool_rx_flow_rule *flow; +struct flow_match_ipv4_addrs ipv4; +struct flow_match_ports ports; +struct flow_match_ip ip;u8 ip_proto, ip_frag;u8 num_udf;u32 reg;
@@ -343,13 +349,9 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port,switch (fs->flow_type & ~FLOW_EXT ) {case TCP_V4_FLOW : ip_proto =IPPROTO_TCP ; - v4_spec = &fs->h_u.tcp_ip4_spec; - v4_m_spec = &fs->m_u.tcp_ip4_spec;break ;case UDP_V4_FLOW : ip_proto =IPPROTO_UDP ; - v4_spec = &fs->h_u.udp_ip4_spec; - v4_m_spec = &fs->m_u.udp_ip4_spec;break ;default :return -EINVAL ;
@@ -367,11 +369,22 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port,if (rule_index >bcm_sf2_cfp_rule_size (priv))return -ENOSPC ; + input.fs = fs; + flow =ethtool_rx_flow_rule_create (&input); +if (IS_ERR (flow)) +return PTR_ERR (flow); + +flow_rule_match_ipv4_addrs (flow->rule, &ipv4); +flow_rule_match_ports (flow->rule, &ports); +flow_rule_match_ip (flow->rule, &ip); + layout = &udf_tcpip4_layout;/* We only use one UDF slice for now */ slice_num =bcm_sf2_get_slice_number (layout,0 ); -if (slice_num ==UDF_NUM_SLICES ) -return -EINVAL ; +if (slice_num ==UDF_NUM_SLICES ) { + ret = -EINVAL ; + goto out_err_flow_rule; + } num_udf =bcm_sf2_get_num_udf_slices (layout->udfs[slice_num].slices);
@@ -398,7 +411,7 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port,* Reserved [1] * UDF_Valid[8] [0] */ -core_writel (priv, v4_spec->tos <<IPTOS_SHIFT | +core_writel (priv, ip.key->tos <<IPTOS_SHIFT | ip_proto <<IPPROTO_SHIFT | ip_frag <<IP_FRAG_SHIFT |udf_upper_bits (num_udf),CORE_CFP_DATA_PORT (6 ));
@@ -417,8 +430,8 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port,core_writel (priv,udf_lower_bits (num_udf) <<24 ,CORE_CFP_MASK_PORT (5 ));/* Program the match and the mask */ -bcm_sf2_cfp_slice_ipv4 (priv, v4_spec, slice_num, false); -bcm_sf2_cfp_slice_ipv4 (priv, v4_m_spec,SLICE_NUM_MASK , true); +bcm_sf2_cfp_slice_ipv4 (priv, ipv4.key, ports.key, slice_num, false); +bcm_sf2_cfp_slice_ipv4 (priv, ipv4.mask, ports.mask,SLICE_NUM_MASK , true);/* Insert into TCAM now */ bcm_sf2_cfp_rule_addr_set (priv, rule_index);
@@ -426,14 +439,14 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port, ret =bcm_sf2_cfp_op (priv,OP_SEL_WRITE |TCAM_SEL );if (ret) {pr_err ("TCAM entry at addr %d failed\n" , rule_index); -return ret; + goto out_err_flow_rule; }/* Insert into Action and policer RAMs now */ ret =bcm_sf2_cfp_act_pol_set (priv, rule_index, port_num, queue_num, true);if (ret) -return ret; + goto out_err_flow_rule;/* Turn on CFP for this rule now */ reg =core_readl (priv,CORE_CFP_CTL_REG );
@@ -446,6 +459,10 @@ static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port, fs->location = rule_index;return 0 ; + +out_err_flow_rule: +ethtool_rx_flow_rule_destroy (flow); +return ret; } static void bcm_sf2_cfp_slice_ipv6(struct bcm_sf2_priv *priv,
@@ -582,8 +599,12 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, struct ethtool_rx_flow_spec *fs) {struct ethtool_tcpip6_spec *v6_spec, *v6_m_spec; +struct ethtool_rx_flow_spec_input input = {};unsigned int slice_num, rule_index[2 ];const struct cfp_udf_layout *layout; +struct ethtool_rx_flow_rule *flow; +struct flow_match_ipv6_addrs ipv6; +struct flow_match_ports ports;u8 ip_proto, ip_frag;int ret =0 ;u8 num_udf;
@@ -645,6 +666,15 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, goto out_err; } + input.fs = fs; + flow =ethtool_rx_flow_rule_create (&input); +if (IS_ERR (flow)) { + ret =PTR_ERR (flow); + goto out_err; + } +flow_rule_match_ipv6_addrs (flow->rule, &ipv6); +flow_rule_match_ports (flow->rule, &ports); +/* Apply the UDF layout for this filter */ bcm_sf2_cfp_udf_set (priv, layout, slice_num);
@@ -688,10 +718,10 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port,core_writel (priv,udf_lower_bits (num_udf) <<24 ,CORE_CFP_MASK_PORT (5 ));/* Slice the IPv6 source address and port */ -bcm_sf2_cfp_slice_ipv6 (priv, v6_spec->ip6src, v6_spec->psrc, - slice_num, false); -bcm_sf2_cfp_slice_ipv6 (priv, v6_m_spec->ip6src, v6_m_spec->psrc, -SLICE_NUM_MASK , true); +bcm_sf2_cfp_slice_ipv6 (priv, ipv6.key->src.in6_u.u6_addr32, + ports.key->src, slice_num, false); +bcm_sf2_cfp_slice_ipv6 (priv, ipv6.mask->src.in6_u.u6_addr32, + ports.mask->src,SLICE_NUM_MASK , true);/* Insert into TCAM now because we need to insert a second rule */ bcm_sf2_cfp_rule_addr_set (priv, rule_index[0 ]);
@@ -699,20 +729,20 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, ret =bcm_sf2_cfp_op (priv,OP_SEL_WRITE |TCAM_SEL );if (ret) {pr_err ("TCAM entry at addr %d failed\n" , rule_index[0 ]); - goto out_err; + goto out_err_flow_rule; }/* Insert into Action and policer RAMs now */ ret =bcm_sf2_cfp_act_pol_set (priv, rule_index[0 ], port_num, queue_num, false);if (ret) - goto out_err; + goto out_err_flow_rule;/* Now deal with the second slice to chain this rule */ slice_num =bcm_sf2_get_slice_number (layout, slice_num +1 );if (slice_num ==UDF_NUM_SLICES ) { ret = -EINVAL ; - goto out_err; + goto out_err_flow_rule; } num_udf =bcm_sf2_get_num_udf_slices (layout->udfs[slice_num].slices);
@@ -748,10 +778,10 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port,/* Mask all */ core_writel (priv,0 ,CORE_CFP_MASK_PORT (5 )); -bcm_sf2_cfp_slice_ipv6 (priv, v6_spec->ip6dst, v6_spec->pdst, slice_num, - false); -bcm_sf2_cfp_slice_ipv6 (priv, v6_m_spec->ip6dst, v6_m_spec->pdst, -SLICE_NUM_MASK , true); +bcm_sf2_cfp_slice_ipv6 (priv, ipv6.key->dst.in6_u.u6_addr32, + ports.key->dst, slice_num, false); +bcm_sf2_cfp_slice_ipv6 (priv, ipv6.mask->dst.in6_u.u6_addr32, + ports.key->dst,SLICE_NUM_MASK , true);/* Insert into TCAM now */ bcm_sf2_cfp_rule_addr_set (priv, rule_index[1 ]);
@@ -759,7 +789,7 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, ret =bcm_sf2_cfp_op (priv,OP_SEL_WRITE |TCAM_SEL );if (ret) {pr_err ("TCAM entry at addr %d failed\n" , rule_index[1 ]); - goto out_err; + goto out_err_flow_rule; }/* Insert into Action and policer RAMs now, set chain ID to
@@ -768,7 +798,7 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, ret =bcm_sf2_cfp_act_pol_set (priv, rule_index[1 ], port_num, queue_num, true);if (ret) - goto out_err; + goto out_err_flow_rule;/* Turn on CFP for this rule now */ reg =core_readl (priv,CORE_CFP_CTL_REG );
@@ -784,6 +814,8 @@ static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port,return ret; +out_err_flow_rule: +ethtool_rx_flow_rule_destroy (flow); out_err:clear_bit (rule_index[1 ], priv->cfp.used);return ret;
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 10/12] dsa: bcm_sf2: use flow_rule infrastructure
Quoted 5 lines · Thu, Dec 06, 2018 at 11:40:00PM CET, [email protected] wrote:
Update this driver to use the
flow_ruleinfrastructure, hence we can use the same code to populate hardware IR fromethtool_rx_flowand thecls_flowerinterfaces.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 11/12 qede: place ethtool_rx_flow_spec after code after TC flower codebase
In reply to Pablo Neira AyusoThis is a preparation patch to reuse the existing TC flower codebase from ethtool_rx_flow_spec.
This patch is merely moving the core ethtool_rx_flow_spec parser after tc flower offload driver code so we can skip a few forward function declarations in the follow up patch.
---
v5: rebase on top of net-next head.
drivers/net/ethernet/qlogic/qede/qede_filter.c | 264 ++++++++++++------------- 1 file changed, 132 insertions(+), 132 deletions(-)
drivers/net/ethernet/qlogic/qede/qede_filter.c +132 -132
@@ -1791,72 +1791,6 @@ static int qede_flow_spec_to_tuple_udpv6(struct qede_dev *edev,return 0 ; } -static int qede_flow_spec_to_tuple (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ -memset (t,0 ,sizeof (*t)); - -if (qede_flow_spec_validate_unused (edev, fs)) -return -EOPNOTSUPP ; - -switch ((fs->flow_type & ~FLOW_EXT )) { -case TCP_V4_FLOW : -return qede_flow_spec_to_tuple_tcpv4 (edev, t, fs); -case UDP_V4_FLOW : -return qede_flow_spec_to_tuple_udpv4 (edev, t, fs); -case TCP_V6_FLOW : -return qede_flow_spec_to_tuple_tcpv6 (edev, t, fs); -case UDP_V6_FLOW : -return qede_flow_spec_to_tuple_udpv6 (edev, t, fs); -default : -DP_VERBOSE (edev,NETIF_MSG_IFUP , -"Can't support flow of type %08x\n" , fs->flow_type); -return -EOPNOTSUPP ; - } - -return 0 ; -} - -static int qede_flow_spec_validate (struct qede_dev *edev, -struct ethtool_rx_flow_spec *fs, -struct qede_arfs_tuple *t) -{ -if (fs->location >=QEDE_RFS_MAX_FLTR ) { -DP_INFO (edev,"Location out-of-bounds\n" ); -return -EINVAL ; - } - -/* Check location isn't already in use */ -if (test_bit (fs->location, edev->arfs->arfs_fltr_bmap)) { -DP_INFO (edev,"Location already in use\n" ); -return -EINVAL ; - } - -/* Check if the filtering-mode could support the filter */ -if (edev->arfs->filter_count && - edev->arfs->mode != t->mode) { -DP_INFO (edev, -"flow_spec would require filtering mode %08x, but %08x is configured\n" , - t->mode, edev->arfs->filter_count); -return -EINVAL ; - } - -/* If drop requested then no need to validate other data */ -if (fs->ring_cookie ==RX_CLS_FLOW_DISC ) -return 0 ; - -if (ethtool_get_flow_spec_ring_vf (fs->ring_cookie)) -return 0 ; - -if (fs->ring_cookie >=QEDE_RSS_COUNT (edev)) { -DP_INFO (edev,"Queue out-of-bounds\n" ); -return -EINVAL ; - } - -return 0 ; -} -/* Must be called while qede lock is held */ static struct qede_arfs_fltr_node *qede_flow_find_fltr (struct qede_dev *edev,struct qede_arfs_tuple *t)
@@ -1896,72 +1830,6 @@ static void qede_flow_set_destination(struct qede_dev *edev, "Configuring N-tuple for VF 0x%02x\n", n->vfid - 1); } -int qede_add_cls_rule (struct qede_dev *edev,struct ethtool_rxnfc *info) -{ -struct ethtool_rx_flow_spec *fsp = &info->fs; -struct qede_arfs_fltr_node *n; -struct qede_arfs_tuple t; -int min_hlen, rc; - -__qede_lock (edev); - -if (!edev->arfs) { - rc = -EPERM ; - goto unlock; - } - -/* Translate the flow specification into something fittign our DB */ - rc =qede_flow_spec_to_tuple (edev, &t, fsp); -if (rc) - goto unlock; - -/* Make sure location is valid and filter isn't already set */ - rc =qede_flow_spec_validate (edev, fsp, &t); -if (rc) - goto unlock; - -if (qede_flow_find_fltr (edev, &t)) { - rc = -EINVAL ; - goto unlock; - } - - n =kzalloc (sizeof (*n),GFP_KERNEL ); -if (!n) { - rc = -ENOMEM ; - goto unlock; - } - - min_hlen =qede_flow_get_min_header_size (&t); - n->data =kzalloc (min_hlen,GFP_KERNEL ); -if (!n->data) { -kfree (n); - rc = -ENOMEM ; - goto unlock; - } - - n->sw_id = fsp->location; -set_bit (n->sw_id, edev->arfs->arfs_fltr_bmap); - n->buf_len = min_hlen; - -memcpy (&n->tuple, &t,sizeof (n->tuple)); - -qede_flow_set_destination (edev, n, fsp); - -/* Build a minimal header according to the flow */ - n->tuple.build_hdr (&n->tuple, n->data); - - rc =qede_enqueue_fltr_and_config_searcher (edev, n,0 ); -if (rc) - goto unlock; - -qede_configure_arfs_fltr (edev, n, n->rxq_id, true); - rc =qede_poll_arfs_filter_config (edev, n); -unlock: -__qede_unlock (edev); - -return rc; -} -int qede_delete_flow_filter (struct qede_dev *edev,u64 cookie) {struct qede_arfs_fltr_node *fltr =NULL ;
@@ -2277,3 +2145,135 @@ int qede_add_tc_flower_fltr(struct qede_dev *edev, __be16 proto,__qede_unlock (edev);return rc; } + +static int qede_flow_spec_validate (struct qede_dev *edev, +struct ethtool_rx_flow_spec *fs, +struct qede_arfs_tuple *t) +{ +if (fs->location >=QEDE_RFS_MAX_FLTR ) { +DP_INFO (edev,"Location out-of-bounds\n" ); +return -EINVAL ; + } + +/* Check location isn't already in use */ +if (test_bit (fs->location, edev->arfs->arfs_fltr_bmap)) { +DP_INFO (edev,"Location already in use\n" ); +return -EINVAL ; + } + +/* Check if the filtering-mode could support the filter */ +if (edev->arfs->filter_count && + edev->arfs->mode != t->mode) { +DP_INFO (edev, +"flow_spec would require filtering mode %08x, but %08x is configured\n" , + t->mode, edev->arfs->filter_count); +return -EINVAL ; + } + +/* If drop requested then no need to validate other data */ +if (fs->ring_cookie ==RX_CLS_FLOW_DISC ) +return 0 ; + +if (ethtool_get_flow_spec_ring_vf (fs->ring_cookie)) +return 0 ; + +if (fs->ring_cookie >=QEDE_RSS_COUNT (edev)) { +DP_INFO (edev,"Queue out-of-bounds\n" ); +return -EINVAL ; + } + +return 0 ; +} + +static int qede_flow_spec_to_tuple (struct qede_dev *edev, +struct qede_arfs_tuple *t, +struct ethtool_rx_flow_spec *fs) +{ +memset (t,0 ,sizeof (*t)); + +if (qede_flow_spec_validate_unused (edev, fs)) +return -EOPNOTSUPP ; + +switch ((fs->flow_type & ~FLOW_EXT )) { +case TCP_V4_FLOW : +return qede_flow_spec_to_tuple_tcpv4 (edev, t, fs); +case UDP_V4_FLOW : +return qede_flow_spec_to_tuple_udpv4 (edev, t, fs); +case TCP_V6_FLOW : +return qede_flow_spec_to_tuple_tcpv6 (edev, t, fs); +case UDP_V6_FLOW : +return qede_flow_spec_to_tuple_udpv6 (edev, t, fs); +default : +DP_VERBOSE (edev,NETIF_MSG_IFUP , +"Can't support flow of type %08x\n" , fs->flow_type); +return -EOPNOTSUPP ; + } + +return 0 ; +} + +int qede_add_cls_rule (struct qede_dev *edev,struct ethtool_rxnfc *info) +{ +struct ethtool_rx_flow_spec *fsp = &info->fs; +struct qede_arfs_fltr_node *n; +struct qede_arfs_tuple t; +int min_hlen, rc; + +__qede_lock (edev); + +if (!edev->arfs) { + rc = -EPERM ; + goto unlock; + } + +/* Translate the flow specification into something fittign our DB */ + rc =qede_flow_spec_to_tuple (edev, &t, fsp); +if (rc) + goto unlock; + +/* Make sure location is valid and filter isn't already set */ + rc =qede_flow_spec_validate (edev, fsp, &t); +if (rc) + goto unlock; + +if (qede_flow_find_fltr (edev, &t)) { + rc = -EINVAL ; + goto unlock; + } + + n =kzalloc (sizeof (*n),GFP_KERNEL ); +if (!n) { + rc = -ENOMEM ; + goto unlock; + } + + min_hlen =qede_flow_get_min_header_size (&t); + n->data =kzalloc (min_hlen,GFP_KERNEL ); +if (!n->data) { +kfree (n); + rc = -ENOMEM ; + goto unlock; + } + + n->sw_id = fsp->location; +set_bit (n->sw_id, edev->arfs->arfs_fltr_bmap); + n->buf_len = min_hlen; + +memcpy (&n->tuple, &t,sizeof (n->tuple)); + +qede_flow_set_destination (edev, n, fsp); + +/* Build a minimal header according to the flow */ + n->tuple.build_hdr (&n->tuple, n->data); + + rc =qede_enqueue_fltr_and_config_searcher (edev, n,0 ); +if (rc) + goto unlock; + +qede_configure_arfs_fltr (edev, n, n->rxq_id, true); + rc =qede_poll_arfs_filter_config (edev, n); +unlock: +__qede_unlock (edev); + +return rc; +}
Signature · 1 line
2.11.0
Re: [PATCH net-next,v5 11/12] qede: place ethtool_rx_flow_spec after code after TC flower codebase
Quoted 8 lines · Thu, Dec 06, 2018 at 11:40:01PM CET, [email protected] wrote:
This is a preparation patch to reuse the existing TC flower codebase from
ethtool_rx_flow_spec.This patch is merely moving the core
ethtool_rx_flow_specparser after tc flower offload driver code so we can skip a few forward function declarations in the follow up patch.Signed-off-by Pablo Neira Ayuso <[email protected]>
PATCH v5 12/12 qede: use ethtool_rx_flow_rule() to remove duplicated parser code
In reply to Pablo Neira AyusoThe qede driver supports for ethtool_rx_flow_spec and flower, both codebases look very similar.
This patch uses the ethtool_rx_flow_rule() infrastructure to remove the duplicated ethtool_rx_flow_spec parser and consolidate ACL offload support around the flow_rule infrastructure.
Furthermore, more code can be consolidated by merging qede_add_cls_rule() and qede_add_tc_flower_fltr(), these two functions also look very similar.
This driver currently provides simple ACL support, such as 5-tuple matching, drop policy and queue to CPU.
Drivers that support more features can benefit from this infrastructure to save even more redundant codebase.
---
v5: rebase on top of net-next head.
drivers/net/ethernet/qlogic/qede/qede_filter.c | 279 +++++++------------------ 1 file changed, 76 insertions(+), 203 deletions(-)
drivers/net/ethernet/qlogic/qede/qede_filter.c +76 -203
@@ -1665,132 +1665,6 @@ static int qede_set_v6_tuple_to_profile(struct qede_dev *edev,return 0 ; } -static int qede_flow_spec_to_tuple_ipv4_common (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ -if ((fs->h_u.tcp_ip4_spec.ip4src & - fs->m_u.tcp_ip4_spec.ip4src) != fs->h_u.tcp_ip4_spec.ip4src) { -DP_INFO (edev,"Don't support IP-masks\n" ); -return -EOPNOTSUPP ; - } - -if ((fs->h_u.tcp_ip4_spec.ip4dst & - fs->m_u.tcp_ip4_spec.ip4dst) != fs->h_u.tcp_ip4_spec.ip4dst) { -DP_INFO (edev,"Don't support IP-masks\n" ); -return -EOPNOTSUPP ; - } - -if ((fs->h_u.tcp_ip4_spec.psrc & - fs->m_u.tcp_ip4_spec.psrc) != fs->h_u.tcp_ip4_spec.psrc) { -DP_INFO (edev,"Don't support port-masks\n" ); -return -EOPNOTSUPP ; - } - -if ((fs->h_u.tcp_ip4_spec.pdst & - fs->m_u.tcp_ip4_spec.pdst) != fs->h_u.tcp_ip4_spec.pdst) { -DP_INFO (edev,"Don't support port-masks\n" ); -return -EOPNOTSUPP ; - } - -if (fs->h_u.tcp_ip4_spec.tos) { -DP_INFO (edev,"Don't support tos\n" ); -return -EOPNOTSUPP ; - } - - t->eth_proto =htons (ETH_P_IP ); - t->src_ipv4 = fs->h_u.tcp_ip4_spec.ip4src; - t->dst_ipv4 = fs->h_u.tcp_ip4_spec.ip4dst; - t->src_port = fs->h_u.tcp_ip4_spec.psrc; - t->dst_port = fs->h_u.tcp_ip4_spec.pdst; - -return qede_set_v4_tuple_to_profile (edev, t); -} - -static int qede_flow_spec_to_tuple_tcpv4 (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ - t->ip_proto =IPPROTO_TCP ; - -if (qede_flow_spec_to_tuple_ipv4_common (edev, t, fs)) -return -EINVAL ; - -return 0 ; -} - -static int qede_flow_spec_to_tuple_udpv4 (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ - t->ip_proto =IPPROTO_UDP ; - -if (qede_flow_spec_to_tuple_ipv4_common (edev, t, fs)) -return -EINVAL ; - -return 0 ; -} - -static int qede_flow_spec_to_tuple_ipv6_common (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ -struct in6_addr zero_addr; - -memset (&zero_addr,0 ,sizeof (zero_addr)); - -if ((fs->h_u.tcp_ip6_spec.psrc & - fs->m_u.tcp_ip6_spec.psrc) != fs->h_u.tcp_ip6_spec.psrc) { -DP_INFO (edev,"Don't support port-masks\n" ); -return -EOPNOTSUPP ; - } - -if ((fs->h_u.tcp_ip6_spec.pdst & - fs->m_u.tcp_ip6_spec.pdst) != fs->h_u.tcp_ip6_spec.pdst) { -DP_INFO (edev,"Don't support port-masks\n" ); -return -EOPNOTSUPP ; - } - -if (fs->h_u.tcp_ip6_spec.tclass) { -DP_INFO (edev,"Don't support tclass\n" ); -return -EOPNOTSUPP ; - } - - t->eth_proto =htons (ETH_P_IPV6 ); -memcpy (&t->src_ipv6, &fs->h_u.tcp_ip6_spec.ip6src, -sizeof (struct in6_addr )); -memcpy (&t->dst_ipv6, &fs->h_u.tcp_ip6_spec.ip6dst, -sizeof (struct in6_addr )); - t->src_port = fs->h_u.tcp_ip6_spec.psrc; - t->dst_port = fs->h_u.tcp_ip6_spec.pdst; - -return qede_set_v6_tuple_to_profile (edev, t, &zero_addr); -} - -static int qede_flow_spec_to_tuple_tcpv6 (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ - t->ip_proto =IPPROTO_TCP ; - -if (qede_flow_spec_to_tuple_ipv6_common (edev, t, fs)) -return -EINVAL ; - -return 0 ; -} - -static int qede_flow_spec_to_tuple_udpv6 (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) -{ - t->ip_proto =IPPROTO_UDP ; - -if (qede_flow_spec_to_tuple_ipv6_common (edev, t, fs)) -return -EINVAL ; - -return 0 ; -} -/* Must be called while qede lock is held */ static struct qede_arfs_fltr_node *qede_flow_find_fltr (struct qede_dev *edev,struct qede_arfs_tuple *t)
@@ -1875,34 +1749,38 @@ static int qede_parse_actions(struct qede_dev *edev, struct flow_action *flow_action) {const struct flow_action_entry *act; -int rc = -EINVAL , num_act =0 , i; -bool is_drop = false; +int i;if (!flow_action_has_entries (flow_action)) { -DP_NOTICE (edev,"No tc actions received\n" ); -return rc; +DP_NOTICE (edev,"No actions received\n" ); +return -EINVAL ; }flow_action_for_each (i, act, flow_action) { - num_act++; +switch (act->id) { +case FLOW_ACTION_DROP : +break ; +case FLOW_ACTION_QUEUE : +if (ethtool_get_flow_spec_ring_vf (act->queue.index)) +break ; -if (act->id ==FLOW_ACTION_DROP ) - is_drop = true; +if (act->queue.index >=QEDE_RSS_COUNT (edev)) { +DP_INFO (edev,"Queue out-of-bounds\n" ); +return -EINVAL ; + } +break ; +default : +return -EINVAL ; + } } -if (num_act ==1 && is_drop) -return 0 ; - -return rc; +return 0 ; }static int -qede_tc_parse_ports (struct qede_dev *edev, -struct tc_cls_flower_offload *f, -struct qede_arfs_tuple *t) +qede_flow_parse_ports (struct qede_dev *edev,struct flow_rule *rule, +struct qede_arfs_tuple *t) { -struct flow_rule *rule =tc_cls_flower_offload_flow_rule (f); -if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_PORTS )) {struct flow_match_ports match;
@@ -1921,11 +1799,9 @@ qede_tc_parse_ports(struct qede_dev *edev, }static int -qede_tc_parse_v6_common (struct qede_dev *edev, -struct tc_cls_flower_offload *f, -struct qede_arfs_tuple *t) +qede_flow_parse_v6_common (struct qede_dev *edev,struct flow_rule *rule, +struct qede_arfs_tuple *t) { -struct flow_rule *rule =tc_cls_flower_offload_flow_rule (f);struct in6_addr zero_addr, addr;memset (&zero_addr,0 ,sizeof (addr));
@@ -1948,19 +1824,16 @@ qede_tc_parse_v6_common(struct qede_dev *edev,memcpy (&t->dst_ipv6, &match.key->dst,sizeof (addr)); } -if (qede_tc_parse_ports (edev, f, t)) +if (qede_flow_parse_ports (edev, rule, t))return -EINVAL ;return qede_set_v6_tuple_to_profile (edev, t, &zero_addr); }static int -qede_tc_parse_v4_common (struct qede_dev *edev, -struct tc_cls_flower_offload *f, +qede_flow_parse_v4_common (struct qede_dev *edev,struct flow_rule *rule,struct qede_arfs_tuple *t) { -struct flow_rule *rule =tc_cls_flower_offload_flow_rule (f); -if (flow_rule_match_key (rule,FLOW_DISSECTOR_KEY_IPV4_ADDRS )) {struct flow_match_ipv4_addrs match;
@@ -1975,62 +1848,56 @@ qede_tc_parse_v4_common(struct qede_dev *edev, t->dst_ipv4 = match.key->dst; } -if (qede_tc_parse_ports (edev, f, t)) +if (qede_flow_parse_ports (edev, rule, t))return -EINVAL ;return qede_set_v4_tuple_to_profile (edev, t); }static int -qede_tc_parse_tcp_v6 (struct qede_dev *edev, -struct tc_cls_flower_offload *f, +qede_flow_parse_tcp_v6 (struct qede_dev *edev,struct flow_rule *rule,struct qede_arfs_tuple *tuple) { tuple->ip_proto =IPPROTO_TCP ; tuple->eth_proto =htons (ETH_P_IPV6 ); -return qede_tc_parse_v6_common (edev, f, tuple); +return qede_flow_parse_v6_common (edev, rule, tuple); }static int -qede_tc_parse_tcp_v4 (struct qede_dev *edev, -struct tc_cls_flower_offload *f, +qede_flow_parse_tcp_v4 (struct qede_dev *edev,struct flow_rule *rule,struct qede_arfs_tuple *tuple) { tuple->ip_proto =IPPROTO_TCP ; tuple->eth_proto =htons (ETH_P_IP ); -return qede_tc_parse_v4_common (edev, f, tuple); +return qede_flow_parse_v4_common (edev, rule, tuple); }static int -qede_tc_parse_udp_v6 (struct qede_dev *edev, -struct tc_cls_flower_offload *f, +qede_flow_parse_udp_v6 (struct qede_dev *edev,struct flow_rule *rule,struct qede_arfs_tuple *tuple) { tuple->ip_proto =IPPROTO_UDP ; tuple->eth_proto =htons (ETH_P_IPV6 ); -return qede_tc_parse_v6_common (edev, f, tuple); +return qede_flow_parse_v6_common (edev, rule, tuple); }static int -qede_tc_parse_udp_v4 (struct qede_dev *edev, -struct tc_cls_flower_offload *f, +qede_flow_parse_udp_v4 (struct qede_dev *edev,struct flow_rule *rule,struct qede_arfs_tuple *tuple) { tuple->ip_proto =IPPROTO_UDP ; tuple->eth_proto =htons (ETH_P_IP ); -return qede_tc_parse_v4_common (edev, f, tuple); +return qede_flow_parse_v4_common (edev, rule, tuple); }static int -qede_parse_flower_attr (struct qede_dev *edev,__be16 proto, -struct tc_cls_flower_offload *f, -struct qede_arfs_tuple *tuple) +qede_parse_flow_attr (struct qede_dev *edev,__be16 proto, +struct flow_rule *rule,struct qede_arfs_tuple *tuple) { -struct flow_rule *rule =tc_cls_flower_offload_flow_rule (f);struct flow_dissector *dissector = rule->match.dissector;int rc = -EINVAL ;u8 ip_proto =0 ;
@@ -2062,15 +1929,15 @@ qede_parse_flower_attr(struct qede_dev *edev, __be16 proto, }if (ip_proto ==IPPROTO_TCP && proto ==htons (ETH_P_IP )) - rc =qede_tc_parse_tcp_v4 (edev, f, tuple); + rc =qede_flow_parse_tcp_v4 (edev, rule, tuple);else if (ip_proto ==IPPROTO_TCP && proto ==htons (ETH_P_IPV6 )) - rc =qede_tc_parse_tcp_v6 (edev, f, tuple); + rc =qede_flow_parse_tcp_v6 (edev, rule, tuple);else if (ip_proto ==IPPROTO_UDP && proto ==htons (ETH_P_IP )) - rc =qede_tc_parse_udp_v4 (edev, f, tuple); + rc =qede_flow_parse_udp_v4 (edev, rule, tuple);else if (ip_proto ==IPPROTO_UDP && proto ==htons (ETH_P_IPV6 )) - rc =qede_tc_parse_udp_v6 (edev, f, tuple); + rc =qede_flow_parse_udp_v6 (edev, rule, tuple);else -DP_NOTICE (edev,"Invalid tc protocol request\n" ); +DP_NOTICE (edev,"Invalid protocol request\n" );return rc; }
@@ -2090,7 +1957,7 @@ int qede_add_tc_flower_fltr(struct qede_dev *edev, __be16 proto, }/* parse flower attribute and prepare filter */ -if (qede_parse_flower_attr (edev, proto, f, &t)) +if (qede_parse_flow_attr (edev, proto, f->rule, &t)) goto unlock;/* Validate profile mode and number of filters */
@@ -2147,16 +2014,17 @@ int qede_add_tc_flower_fltr(struct qede_dev *edev, __be16 proto, }static int qede_flow_spec_validate (struct qede_dev *edev, -struct ethtool_rx_flow_spec *fs, -struct qede_arfs_tuple *t) +struct flow_action *flow_action, +struct qede_arfs_tuple *t, +__u32 location) { -if (fs->location >=QEDE_RFS_MAX_FLTR ) { +if (location >=QEDE_RFS_MAX_FLTR ) {DP_INFO (edev,"Location out-of-bounds\n" );return -EINVAL ; }/* Check location isn't already in use */ -if (test_bit (fs->location, edev->arfs->arfs_fltr_bmap)) { +if (test_bit (location, edev->arfs->arfs_fltr_bmap)) {DP_INFO (edev,"Location already in use\n" );return -EINVAL ; }
@@ -2170,46 +2038,56 @@ static int qede_flow_spec_validate(struct qede_dev *edev,return -EINVAL ; } -/* If drop requested then no need to validate other data */ -if (fs->ring_cookie ==RX_CLS_FLOW_DISC ) -return 0 ; - -if (ethtool_get_flow_spec_ring_vf (fs->ring_cookie)) -return 0 ; - -if (fs->ring_cookie >=QEDE_RSS_COUNT (edev)) { -DP_INFO (edev,"Queue out-of-bounds\n" ); +if (qede_parse_actions (edev, flow_action))return -EINVAL ; - }return 0 ; } -static int qede_flow_spec_to_tuple (struct qede_dev *edev, -struct qede_arfs_tuple *t, -struct ethtool_rx_flow_spec *fs) +static int qede_flow_spec_to_rule (struct qede_dev *edev, +struct qede_arfs_tuple *t, +struct ethtool_rx_flow_spec *fs) { -memset (t,0 ,sizeof (*t)); +struct ethtool_rx_flow_spec_input input = {}; +struct ethtool_rx_flow_rule *flow; +__be16 proto; +int err =0 ;if (qede_flow_spec_validate_unused (edev, fs))return -EOPNOTSUPP ;switch ((fs->flow_type & ~FLOW_EXT )) {case TCP_V4_FLOW : -return qede_flow_spec_to_tuple_tcpv4 (edev, t, fs);case UDP_V4_FLOW : -return qede_flow_spec_to_tuple_udpv4 (edev, t, fs); + proto =htons (ETH_P_IP ); +break ;case TCP_V6_FLOW : -return qede_flow_spec_to_tuple_tcpv6 (edev, t, fs);case UDP_V6_FLOW : -return qede_flow_spec_to_tuple_udpv6 (edev, t, fs); + proto =htons (ETH_P_IPV6 ); +break ;default :DP_VERBOSE (edev,NETIF_MSG_IFUP ,"Can't support flow of type %08x\n" , fs->flow_type);return -EOPNOTSUPP ; } -return 0 ; + input.fs = fs; + flow =ethtool_rx_flow_rule_create (&input); +if (IS_ERR (flow)) +return PTR_ERR (flow); + +if (qede_parse_flow_attr (edev, proto, flow->rule, t)) { + err = -EINVAL ; + goto err_out; + } + +/* Make sure location is valid and filter isn't already set */ + err =qede_flow_spec_validate (edev, &flow->rule->action, t, + fs->location); +err_out: +ethtool_rx_flow_rule_destroy (flow); +return err; + }int qede_add_cls_rule (struct qede_dev *edev,struct ethtool_rxnfc *info)
@@ -2227,12 +2105,7 @@ int qede_add_cls_rule(struct qede_dev *edev, struct ethtool_rxnfc *info) }/* Translate the flow specification into something fittign our DB */ - rc =qede_flow_spec_to_tuple (edev, &t, fsp); -if (rc) - goto unlock; - -/* Make sure location is valid and filter isn't already set */ - rc =qede_flow_spec_validate (edev, fsp, &t); + rc =qede_flow_spec_to_rule (edev, &t, fsp);if (rc) goto unlock;
Signature · 1 line
2.11.0
Pablo Neira Ayuso <[email protected]> wrote:
[ trimming CCs ]
Quoted 4 lines
This is another iteration of the in-kernel intermediate representation (IR) that allows to express ACL hardware offloads using one unified representation from the driver side for the ethtool and the tc frontends [1] [2] [3].
[..]
This is marked 'rejected' in patchwork, what happened?
David Miller
maintainerFrom: Florian Westphal <[email protected]>
Date: Tue, 11 Dec 2018 16:35:19 +0100
Quoted 4 lines
Pablo Neira Ayuso <[email protected]> wrote:
[ trimming CCs ]
Quoted 8 lines
Quoted 4 lines
This is another iteration of the in-kernel intermediate representation (IR) that allows to express ACL hardware offloads using one unified representation from the driver side for the ethtool and the tc frontends [1] [2] [3].
[..]
This is marked 'rejected' in patchwork, what happened?
Pablo is not being honest about his true intentions and long term goals with this series. Or also brought up fundamental objections against previous versions of this series which were not sufficiently addressed by Pablo.
My personal concern has been brought up several times.
I am not going to restate the same thing over and over, and he hasn't fixed up his introductory posting in response to my concerns in any meaningful and full way.
Therefore, if I feel like my and Or's feedback will keep being ignored, I will keep rejecting these changes.
Quoted 7 lines · David Miller
From: Florian Westphal <[email protected]>
Quoted 5 lines
Quoted 4 lines · Pablo Neira Ayuso
This is another iteration of the in-kernel intermediate representation (IR) that allows to express ACL hardware offloads using one unified representation from the driver side for the ethtool and the tc frontends [1] [2] [3].
Quoted 6 lines
Quoted 1 line
This is marked 'rejected' in patchwork, what happened?
Pablo is not being honest about his true intentions and long term goals with this series. Or also brought up fundamental objections against previous versions of this series which were not sufficiently addressed by Pablo.
H Dave,
To put it a bit more clearly, donno if my concerns are to the extent of being fundamental, but yesknow that they were not sufficiently addressed.
TC is the leading kernel CA system for about 2.5 decades, so I am not clear what we want to IR the TC offload path and not TCfy the ethtool and Co offloads path.
9
Going forward to 2019 HWs that can offload OVS/OF (flow) metering, do we really want to IR the TC policers which follow IEEE or a like specs?
Still, seems that other folks on the drivers yard are ok and even happy with the IR direction/implementation, I see that Jiri acked it all.
I guess we need some voices to speak, would love to hear the whole of the CCed JJJ triplet speaking up.
Quoted 1 line
My personal concern has been brought up several times.
I will go dig for it, that's ineed hard when concerns are not replied :(
Quoted 6 lines
I am not going to restate the same thing over and over, and he hasn't fixed up his introductory posting in response to my concerns in any meaningful and full way.
Therefore, if I feel like my and Or's feedback will keep being ignored, I will keep rejecting these changes.
Quoted 6 lines · Or Gerlitz
To put it a bit more clearly, donno if my concerns are to the extent of being fundamental, but yesknow that they were not sufficiently addressed.
TC is the leading kernel CA system for about 2.5 decades, so I am not clear what we want to IR the TC offload path and not TCfy the ethtool and Co offloads path.
I'm not 100% clear on what the proposal would be here. Would we build a flow dissector and allocate fake TC actions? Would we use setup_tc hook? My gut worry is that we would just end up with the worst of all worlds if we do something like this :( (already to my taste this API leaks too much TC through)
Back to the elephant in the room it would certainly aid "nft offload" adoption if drivers didn't even know it was not a real flower being offloaded :)
Quoted 2 lines
Going forward to 2019 HWs that can offload OVS/OF (flow) metering, do we really want to IR the TC policers which follow IEEE or a like specs?
Specs are good (y)
Quoted 5 lines
Still, seems that other folks on the drivers yard are ok and even happy with the IR direction/implementation, I see that Jiri acked it all.
I guess we need some voices to speak, would love to hear the whole of the CCed JJJ triplet speaking up.
I don't care much either way. One thing I really don't look forward to is trying to do backports and send stable fixes after this conversion.
Maybe having a side library that could take a ethtool/flower/nft flow and return common IR representation of that flow would be less painful? Drivers could then migrate at its own pace, for new functionality etc. Was that discussed before? I may have lost track of this discussion...
Quoted 9 lines · Jakub Kicinski
Quoted 6 lines · Or Gerlitz
To put it a bit more clearly, donno if my concerns are to the extent of being fundamental, but yesknow that they were not sufficiently addressed.
TC is the leading kernel CA system for about 2.5 decades, so I am not clear what we want to IR the TC offload path and not TCfy the ethtool and Co offloads path.
Quoted 5 lines
I'm not 100% clear on what the proposal would be here. Would we build a flow dissector and allocate fake TC actions? Would we use
setup_tchook? My gut worry is that we would just end up with the worst of all worlds if we do something like this :( (already to my taste this API leaks too much TC through)
yeah it was something in this direction, but I hear that you don't like it and I guess Jiri is also not advocating for that, so maybe that not a right choice.
Quoted 3 lines
Back to the elephant in the room it would certainly aid "nft offload" adoption if drivers didn't even know it was not a real flower being offloaded :)
after this Dave put the EIR on the thread someone put on table a photo of office scene with nice Elephant looking on the happenings, so I have it every morning now..
Quoted 4 lines
Quoted 2 lines
Going forward to 2019 HWs that can offload OVS/OF (flow) metering, do we really want to IR the TC policers which follow IEEE or a like specs?
Specs are good (y)
I understand you are saying we can IR the TC policers, let it be.
Quoted 8 lines
Quoted 5 lines
Still, seems that other folks on the drivers yard are ok and even happy with the IR direction/implementation, I see that Jiri acked it all.
I guess we need some voices to speak, would love to hear the whole of the CCed JJJ triplet speaking up.
I don't care much either way. One thing I really don't look forward to is trying to do backports and send stable fixes after this conversion.
M2
Quoted 4 lines
Maybe having a side library that could take a ethtool/flower/nft flow and return common IR representation of that flow would be less painful? Drivers could then migrate at its own pace, for new functionality etc. Was that discussed before? I may have lost track of this discussion...
Currently all drivers are ported to use the IR on the tc/flower offload path
End of the day, seems that Jiri and Jakub are good with this and I didn't hear any further rejections from other driver folks, so I guess my concerns were basically
addressed by them.
Quoted 10 lines · Or Gerlitz
Quoted 4 lines
Maybe having a side library that could take a ethtool/flower/nft flow and return common IR representation of that flow would be less painful? Drivers could then migrate at its own pace, for new functionality etc. Was that discussed before? I may have lost track of this discussion...
Currently all drivers are ported to use the IR on the tc/flower offload path
End of the day, seems that Jiri and Jakub are good with this and I didn't hear any further rejections from other driver folks, so I guess my concerns were basically addressed by them.
I think having the drivers call the IR translation could be a good compromise instead of having flower always pass down converted flows.
tc flower -> flower offload object -> setup_tc -> driver ->
-> flow_offload_from_flower() -> driver -> driver's common handling
This patchset already does that for ethtool:
ethtool -> ethtool flow -> ethtool_op -> driver ->
-> ethtool_rx_flow_rule_create() -> driver -> driver's common handling
It feels like a bit of a waste to let the driver patches go, but perhaps it's a good way to move forward?
Quoted 18 lines · Jakub Kicinski
Quoted 10 lines · Or Gerlitz
Quoted 4 lines
Maybe having a side library that could take a ethtool/flower/nft flow and return common IR representation of that flow would be less painful? Drivers could then migrate at its own pace, for new functionality etc. Was that discussed before? I may have lost track of this discussion...
Currently all drivers are ported to use the IR on the tc/flower offload path
End of the day, seems that Jiri and Jakub are good with this and I didn't hear any further rejections from other driver folks, so I guess my concerns were basically addressed by them.
I think having the drivers call the IR translation could be a good compromise instead of having flower always pass down converted flows.
tc flower -> flower offload object ->
setup_tc-> driver ->
->flow_offload_from_flower()-> driver -> driver's common handling
Quoted 7 lines
This patchset already does that for ethtool:
ethtool -> ethtool flow ->
ethtool_op-> driver ->
->ethtool_rx_flow_rule_create()-> driver -> driver's common handlingIt feels like a bit of a waste to let the driver patches go, but perhaps it's a good way to move forward?
I think Michal Kubecek mentioned that it would be good if, moving forward, core/ethtool.c calls ethtool_rx_flow_rule_create(), so this is:
ethtool -> ethtool flow -> ethtool_rx_flow_rule_create() ->
-> ethtool_op -> driver -> driver's common handling
In that case, ethtool would match what flower is doing.
We can probably offer the flow_rule representation as parameter via ethtool_op indirection, so there is a single ethtool_rx_flow_rule_create() call. Still, this new infrastructure is used by two ethtool drivers, so probably it is too early for this consolidation work.
Quoted 21 lines · Pablo Neira Ayuso
Quoted 6 lines · Jakub Kicinski
I think having the drivers call the IR translation could be a good compromise instead of having flower always pass down converted flows.
tc flower -> flower offload object ->
setup_tc-> driver ->
->flow_offload_from_flower()-> driver -> driver's common handlingQuoted 7 lines
This patchset already does that for ethtool:
ethtool -> ethtool flow ->
ethtool_op-> driver ->
->ethtool_rx_flow_rule_create()-> driver -> driver's common handlingIt feels like a bit of a waste to let the driver patches go, but perhaps it's a good way to move forward?
I think Michal Kubecek mentioned that it would be good if, moving forward,
core/ethtool.ccallsethtool_rx_flow_rule_create(), so this is:ethtool -> ethtool flow ->
ethtool_rx_flow_rule_create()->
->ethtool_op-> driver -> driver's common handling
Quoted 6 lines
In that case, ethtool would match what flower is doing.
We can probably offer the
flow_rulerepresentation as parameter viaethtool_opindirection, so there is a singleethtool_rx_flow_rule_create()call. Still, this new infrastructure is used by two ethtool drivers, so probably it is too early for this consolidation work.
The main reason why I would prefer the translation in the generic ethtool code is that once we have netlink interface for ethtool, current model would require us to translate netlink messages to the data structures for current ethtool_ops handlers (which are essentially the same as those used by ethtool ioctl interface) only to translate them once more in the NIC handler to the common representation.
So in the long term it seems better to let ethtool_ops use your representation of Rx flow rules and translate both the ioctl structures and netlink messages into it in the generic code so that NIC drivers would only work with flow_rule.
But at the moment, this would mean a lot of work for not so much gain as it would mean adjusting all NIC drivers supporting Rx flow rule handling via ethtool. Also, it would look strange if the new ethtool_ops handlers passed extack which the only caller wouldn't use.
Michal Kubecek