flow_offload: update mangle action representation
Subsystems (8)
Pablo Neira Ayuso
maintainerv3 cover flow_offload: update mangle action representation
This patch updates the mangle action representation:
Patch 1) Undo bitwise NOT operation on the mangle mask (coming from tc
pedit userspace).
Patch 2) mangle value &= mask from the front-end side.
Patch 3) adjust offset, length and coalesce consecutive pedit keys into
one single action.
Patch 4) add support for payload mangling for netfilter.
After this patchset:
* Offset to payload does not need to be on the 32-bits boundaries anymore. This patchset adds front-end code to adjust the offset and length coming from the tc pedit representation, so drivers get an exact header field offset and length.
* This new front-end code coalesces consecutive pedit actions into one single action, so drivers can mangle IPv6 and ethernet address fields in one go, instead once for each 32-bit word.
On the driver side, diffstat -t shows that drivers code to deal with payload mangling gets simplified:
INSERTED,DELETED,MODIFIED,FILENAME
46,116,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c (-70 LOC)
12,28,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h (-16 LOC)
26,54,0,drivers/net/ethernet/mellanox/mlx5/core/en_tc.c (-27 LOC)
89,111,0,drivers/net/ethernet/netronome/nfp/flower/action.c (-17 LOC)While, on the front-end side the balance is the following:
123,22,0,net/sched/cls_api.c (+101 LOC)
Changes since v2:
* Fix is_action_keys_supported() breakage in mlx5 reported by Vlad Buslov.
Pablo Neira Ayuso (4):
net: flow_offload: flip mangle action mask
net: flow_offload: bitwise AND on mangle action value field
net: flow_offload: mangle action at byte level
netfilter: nft_payload: packet mangling offload support
.../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 163 +++++----------- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h | 40 ++-- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 80 +++----- drivers/net/ethernet/netronome/nfp/flower/action.c | 204 ++++++++++----------- include/net/flow_offload.h | 7 +- net/netfilter/nft_payload.c | 73 ++++++++ net/sched/cls_api.c | 144 ++++++++++++--- 7 files changed, 378 insertions(+), 333 deletions(-)
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 1/4 net: flow_offload: flip mangle action mask
Userspace tc pedit action performs a bitwise NOT operation on the mask. All of the existing drivers in the tree undo this operation. Prepare the mangle mask in the way the drivers expect from the tc_setup_flow_action() function.
--- drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 12 ++++++------ drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 6 +++--- drivers/net/ethernet/netronome/nfp/flower/action.c | 8 ++++---- net/sched/cls_api.c | 2 +- 4 files changed, 14 insertions(+), 14 deletions(-)
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +6 -6
@@ -275,7 +275,7 @@ static int cxgb4_validate_flow_match(struct net_device *dev,static void offload_pedit (struct ch_filter_specification *fs,u32 val,u32 mask,u8 field) { -u32 set_val = val & ~mask; +u32 set_val = val & mask;u32 offset =0 ;u8 size =1 ;int i;
@@ -301,7 +301,7 @@ static void process_pedit_field(struct ch_filter_specification *fs, u32 val,offload_pedit (fs, val, mask,ETH_DMAC_31_0 );break ;case PEDIT_ETH_DMAC_47_32_SMAC_15_0 : -if (~mask &PEDIT_ETH_DMAC_MASK ) +if (mask &PEDIT_ETH_DMAC_MASK )offload_pedit (fs, val, mask,ETH_DMAC_47_32 );else offload_pedit(fs, val >> 16, mask >> 16,
@@ -353,7 +353,7 @@ static void process_pedit_field(struct ch_filter_specification *fs, u32 val,case FLOW_ACT_MANGLE_HDR_TYPE_TCP :switch (offset) {case PEDIT_TCP_SPORT_DPORT : -if (~mask &PEDIT_TCP_UDP_SPORT_MASK ) +if (mask &PEDIT_TCP_UDP_SPORT_MASK )offload_pedit (fs,cpu_to_be32 (val) >>16 ,cpu_to_be32 (mask) >>16 ,TCP_SPORT );
@@ -366,7 +366,7 @@ static void process_pedit_field(struct ch_filter_specification *fs, u32 val,case FLOW_ACT_MANGLE_HDR_TYPE_UDP :switch (offset) {case PEDIT_UDP_SPORT_DPORT : -if (~mask &PEDIT_TCP_UDP_SPORT_MASK ) +if (mask &PEDIT_TCP_UDP_SPORT_MASK )offload_pedit (fs,cpu_to_be32 (val) >>16 ,cpu_to_be32 (mask) >>16 ,UDP_SPORT );
@@ -510,7 +510,7 @@ static bool valid_pedit_action(struct net_device *dev,case FLOW_ACT_MANGLE_HDR_TYPE_TCP :switch (offset) {case PEDIT_TCP_SPORT_DPORT : -if (!valid_l4_mask (~mask)) { +if (!valid_l4_mask (mask)) {netdev_err (dev,"%s: Unsupported mask for TCP L4 ports\n" , __func__);return false;
@@ -525,7 +525,7 @@ static bool valid_pedit_action(struct net_device *dev,case FLOW_ACT_MANGLE_HDR_TYPE_UDP :switch (offset) {case PEDIT_UDP_SPORT_DPORT : -if (!valid_l4_mask (~mask)) { +if (!valid_l4_mask (mask)) {netdev_err (dev,"%s: Unsupported mask for UDP L4 ports\n" , __func__);return false;
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +3 -3
@@ -2509,7 +2509,7 @@ static int parse_tc_pedit_action(struct mlx5e_priv *priv, val = act->mangle.val; offset = act->mangle.offset; - err =set_pedit_val (htype, ~mask, val, offset, &hdrs[cmd]); + err =set_pedit_val (htype, mask, val, offset, &hdrs[cmd]);if (err) goto out_err;
@@ -2609,7 +2609,7 @@ static bool is_action_keys_supported(const struct flow_action_entry *act) htype = act->mangle.htype; offset = act->mangle.offset; - mask = ~act->mangle.mask; + mask = act->mangle.mask;/* For IPv4 & IPv6 header check 4 byte word, * to determine that modified fields * are NOT ttl & hop_limit only.
@@ -2733,7 +2733,7 @@ static int add_vlan_rewrite_action(struct mlx5e_priv *priv, int namespace, .id = FLOW_ACTION_MANGLE, .mangle.htype = FLOW_ACT_MANGLE_HDR_TYPE_ETH, .mangle.offset = offsetof(struct vlan_ethhdr, h_vlan_TCI), - .mangle.mask = ~(u32)be16_to_cpu(*(__be16 *)&mask16), + .mangle.mask = (u32)be16_to_cpu(*(__be16 *)&mask16), .mangle.val = (u32)be16_to_cpu(*(__be16 *)&val16), };u8 match_prio_mask, match_prio_val;
drivers/net/ethernet/netronome/nfp/flower/action.c +4 -4
@@ -495,7 +495,7 @@ nfp_fl_set_eth(const struct flow_action_entry *act, u32 off,return -EOPNOTSUPP ; } - mask = ~act->mangle.mask; + mask = act->mangle.mask; exact = act->mangle.val;if (exact & ~mask) {
@@ -532,7 +532,7 @@ nfp_fl_set_ip4(const struct flow_action_entry *act, u32 off,__be32 exact, mask;/* We are expecting tcf_pedit to return a big endian value */ - mask = (__force __be32 )~act->mangle.mask; + mask = (__force __be32 )act->mangle.mask; exact = (__force __be32 )act->mangle.val;if (exact & ~mask) {
@@ -673,7 +673,7 @@ nfp_fl_set_ip6(const struct flow_action_entry *act, u32 off,u8 word;/* We are expecting tcf_pedit to return a big endian value */ - mask = (__force __be32 )~act->mangle.mask; + mask = (__force __be32 )act->mangle.mask; exact = (__force __be32 )act->mangle.val;if (exact & ~mask) {
@@ -713,7 +713,7 @@ nfp_fl_set_tport(const struct flow_action_entry *act, u32 off,return -EOPNOTSUPP ; } - mask = ~act->mangle.mask; + mask = act->mangle.mask; exact = act->mangle.val;if (exact & ~mask) {
net/sched/cls_api.c +1 -1
@@ -3379,7 +3379,7 @@ int tc_setup_flow_action(struct flow_action *flow_action, goto err_out; } entry->mangle.htype =tcf_pedit_htype (act, k); - entry->mangle.mask =tcf_pedit_mask (act, k); + entry->mangle.mask = ~tcf_pedit_mask (act, k); entry->mangle.val =tcf_pedit_val (act, k); entry->mangle.offset =tcf_pedit_offset (act, k); entry = &flow_action->entries[++j];
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 2/4 net: flow_offload: bitwise AND on mangle action value field
In reply to Pablo Neira AyusoDrivers perform a bitwise AND on the value and the mask. Update tc_setup_flow_action() to perform this operation so drivers do not need to do this.
--- drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 3 +-- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 2 +- drivers/net/ethernet/netronome/nfp/flower/action.c | 9 ++++----- net/sched/cls_api.c | 3 ++- 4 files changed, 8 insertions(+), 9 deletions(-)
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +1 -2
@@ -275,7 +275,6 @@ static int cxgb4_validate_flow_match(struct net_device *dev,static void offload_pedit (struct ch_filter_specification *fs,u32 val,u32 mask,u8 field) { -u32 set_val = val & mask;u32 offset =0 ;u8 size =1 ;int i;
@@ -287,7 +286,7 @@ static void offload_pedit(struct ch_filter_specification *fs, u32 val, u32 mask,break ; } } -memcpy ((u8 *)fs + offset, &set_val, size); +memcpy ((u8 *)fs + offset, &val, size); } static void process_pedit_field(struct ch_filter_specification *fs, u32 val,
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +1 -1
@@ -2214,7 +2214,7 @@ static int set_pedit_val(u8 hdr_type, u32 mask, u32 val, u32 offset, goto out_err; *curr_pmask |= mask; - *curr_pval |= (val & mask); + *curr_pval |= val;return 0 ;
drivers/net/ethernet/netronome/nfp/flower/action.c +4 -5
@@ -477,7 +477,6 @@ static void nfp_fl_set_helper32(u32 value, u32 mask, u8 *p_exact, u8 *p_mask)u32 oldvalue =get_unaligned ((u32 *)p_exact);u32 oldmask =get_unaligned ((u32 *)p_mask); - value &= mask; value |= oldvalue & ~mask;put_unaligned (oldmask | mask, (u32 *)p_mask);
@@ -544,7 +543,7 @@ nfp_fl_set_ip4(const struct flow_action_entry *act, u32 off,case offsetof(struct iphdr , daddr): set_ip_addr->ipv4_dst_mask |= mask; set_ip_addr->ipv4_dst &= ~mask; - set_ip_addr->ipv4_dst |= exact & mask; + set_ip_addr->ipv4_dst |= exact; set_ip_addr->head.jump_id =NFP_FL_ACTION_OPCODE_SET_IPV4_ADDRS ; set_ip_addr->head.len_lw =sizeof (*set_ip_addr) >>NFP_FL_LW_SIZ ;
@@ -552,7 +551,7 @@ nfp_fl_set_ip4(const struct flow_action_entry *act, u32 off,case offsetof(struct iphdr , saddr): set_ip_addr->ipv4_src_mask |= mask; set_ip_addr->ipv4_src &= ~mask; - set_ip_addr->ipv4_src |= exact & mask; + set_ip_addr->ipv4_src |= exact; set_ip_addr->head.jump_id =NFP_FL_ACTION_OPCODE_SET_IPV4_ADDRS ; set_ip_addr->head.len_lw =sizeof (*set_ip_addr) >>NFP_FL_LW_SIZ ;
@@ -606,7 +605,7 @@ nfp_fl_set_ip6_helper(int opcode_tag, u8 word, __be32 exact, __be32 mask, { ip6->ipv6[word].mask |= mask; ip6->ipv6[word].exact &= ~mask; - ip6->ipv6[word].exact |= exact & mask; + ip6->ipv6[word].exact |= exact; ip6->reserved =cpu_to_be16 (0 ); ip6->head.jump_id = opcode_tag;
@@ -651,7 +650,7 @@ nfp_fl_set_ip6_hop_limit_flow_label(u32 off, __be32 exact, __be32 mask, ip_hl_fl->ipv6_label_mask |= mask; ip_hl_fl->ipv6_label &= ~mask; - ip_hl_fl->ipv6_label |= exact & mask; + ip_hl_fl->ipv6_label |= exact;break ; }
net/sched/cls_api.c +2 -1
@@ -3380,7 +3380,8 @@ int tc_setup_flow_action(struct flow_action *flow_action, } entry->mangle.htype =tcf_pedit_htype (act, k); entry->mangle.mask = ~tcf_pedit_mask (act, k); - entry->mangle.val =tcf_pedit_val (act, k); + entry->mangle.val =tcf_pedit_val (act, k) & + entry->mangle.mask; entry->mangle.offset =tcf_pedit_offset (act, k); entry = &flow_action->entries[++j]; }
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 3/4 net: flow_offload: mangle action at byte level
In reply to Pablo Neira AyusoThe flow mangle action is originally modeled after the tc pedit action, this has a number of shortcomings:
1) The tc pedit offset must be set on the 32-bits boundaries. Many protocol header field offsets are not aligned to 32-bits, eg. port destination, port source and ethernet destination. This patch adjusts the offset accordingly and trim off length in these case, so drivers get an exact offset and length to the header fields.
2) The maximum mangle length is one word of 32-bits, hence you need to up to four actions to mangle an IPv6 address. This patch coalesces consecutive tc pedit actions into one single action so drivers can configure the IPv6 mangling in one go. Ethernet address fields now require one single action instead of two too.
The following drivers have been updated accordingly to use this new mangle action layout:
1) The cxgb4 driver does not need to split protocol field matching larger than one 32-bit words into multiple definitions. Instead one single definition per protocol field is enough. Checking for transport protocol ports is also simplified.
2) The mlx5 driver logic to disallow IPv4 ttl and IPv6 hoplimit fields becomes more simple too.
3) The nfp driver uses the nfp_fl_set_helper() function to configure the payload mangling. The memchr_inv() function is used to check for proper initialization of the value and mask. The driver has been updated to refer to the exact protocol header offsets too.
As a result, this patch reduces code complexity on the driver side at the cost of adding ~100 LOC at the core to perform offset and length adjustment; and to coalesce consecutive actions.
--- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c | 162 +++++----------- .../net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h | 40 ++-- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 80 +++----- drivers/net/ethernet/netronome/nfp/flower/action.c | 203 ++++++++++----------- include/net/flow_offload.h | 7 +- net/sched/cls_api.c | 145 ++++++++++++--- 6 files changed, 305 insertions(+), 332 deletions(-)
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +46 -116
@@ -44,20 +44,12 @@#define STATS_CHECK_PERIOD (HZ / 2)static struct ch_tc_pedit_fields pedits[] = { -PEDIT_FIELDS (ETH_ ,DMAC_31_0 ,4 , dmac,0 ), -PEDIT_FIELDS (ETH_ ,DMAC_47_32 ,2 , dmac,4 ), -PEDIT_FIELDS (ETH_ ,SMAC_15_0 ,2 , smac,0 ), -PEDIT_FIELDS (ETH_ ,SMAC_47_16 ,4 , smac,2 ), +PEDIT_FIELDS (ETH_ ,DMAC ,6 , dmac,0 ), +PEDIT_FIELDS (ETH_ ,SMAC ,6 , smac,0 ),PEDIT_FIELDS (IP4_ ,SRC ,4 , nat_fip,0 ),PEDIT_FIELDS (IP4_ ,DST ,4 , nat_lip,0 ), -PEDIT_FIELDS (IP6_ ,SRC_31_0 ,4 , nat_fip,0 ), -PEDIT_FIELDS (IP6_ ,SRC_63_32 ,4 , nat_fip,4 ), -PEDIT_FIELDS (IP6_ ,SRC_95_64 ,4 , nat_fip,8 ), -PEDIT_FIELDS (IP6_ ,SRC_127_96 ,4 , nat_fip,12 ), -PEDIT_FIELDS (IP6_ ,DST_31_0 ,4 , nat_lip,0 ), -PEDIT_FIELDS (IP6_ ,DST_63_32 ,4 , nat_lip,4 ), -PEDIT_FIELDS (IP6_ ,DST_95_64 ,4 , nat_lip,8 ), -PEDIT_FIELDS (IP6_ ,DST_127_96 ,4 , nat_lip,12 ), +PEDIT_FIELDS (IP6_ ,SRC ,16 , nat_fip,0 ), +PEDIT_FIELDS (IP6_ ,DST ,16 , nat_lip,0 ),PEDIT_FIELDS (TCP_ ,SPORT ,2 , nat_fport,0 ),PEDIT_FIELDS (TCP_ ,DPORT ,2 , nat_lport,0 ),PEDIT_FIELDS (UDP_ ,SPORT ,2 , nat_fport,0 ),
@@ -272,8 +264,8 @@ static int cxgb4_validate_flow_match(struct net_device *dev,return 0 ; } -static void offload_pedit (struct ch_filter_specification *fs,u32 val,u32 mask, -u8 field) +static void offload_pedit (struct ch_filter_specification *fs, +struct flow_action_entry *act,u8 field) {u32 offset =0 ;u8 size =1 ;
@@ -286,92 +278,68 @@ static void offload_pedit(struct ch_filter_specification *fs, u32 val, u32 mask,break ; } } -memcpy ((u8 *)fs + offset, &val, size); +memcpy ((u8 *)fs + offset, act->mangle.val, size); } -static void process_pedit_field (struct ch_filter_specification *fs,u32 val, -u32 mask,u32 offset,u8 htype) +static void process_pedit_field (struct ch_filter_specification *fs, +struct flow_action_entry *act) { +u32 offset = act->mangle.offset; +u8 htype = act->mangle.htype; +switch (htype) {case FLOW_ACT_MANGLE_HDR_TYPE_ETH :switch (offset) { -case PEDIT_ETH_DMAC_31_0 : +case PEDIT_ETH_DMAC : fs->newdmac =1 ; -offload_pedit (fs, val, mask,ETH_DMAC_31_0 ); -break ; -case PEDIT_ETH_DMAC_47_32_SMAC_15_0 : -if (mask &PEDIT_ETH_DMAC_MASK ) -offload_pedit (fs, val, mask,ETH_DMAC_47_32 ); -else -offload_pedit (fs, val >>16 , mask >>16 , -ETH_SMAC_15_0 ); +offload_pedit (fs, act,ETH_DMAC );break ; -case PEDIT_ETH_SMAC_47_16 : +case PEDIT_ETH_SMAC : fs->newsmac =1 ; -offload_pedit (fs, val, mask,ETH_SMAC_47_16 ); +offload_pedit (fs, act,ETH_SMAC ); +break ; }break ;case FLOW_ACT_MANGLE_HDR_TYPE_IP4 :switch (offset) {case PEDIT_IP4_SRC : -offload_pedit (fs, val, mask,IP4_SRC ); +offload_pedit (fs, act,IP4_SRC );break ;case PEDIT_IP4_DST : -offload_pedit (fs, val, mask,IP4_DST ); +offload_pedit (fs, act,IP4_DST ); } fs->nat_mode =NAT_MODE_ALL ;break ;case FLOW_ACT_MANGLE_HDR_TYPE_IP6 :switch (offset) { -case PEDIT_IP6_SRC_31_0 : -offload_pedit (fs, val, mask,IP6_SRC_31_0 ); -break ; -case PEDIT_IP6_SRC_63_32 : -offload_pedit (fs, val, mask,IP6_SRC_63_32 ); -break ; -case PEDIT_IP6_SRC_95_64 : -offload_pedit (fs, val, mask,IP6_SRC_95_64 ); -break ; -case PEDIT_IP6_SRC_127_96 : -offload_pedit (fs, val, mask,IP6_SRC_127_96 ); -break ; -case PEDIT_IP6_DST_31_0 : -offload_pedit (fs, val, mask,IP6_DST_31_0 ); +case PEDIT_IP6_SRC : +offload_pedit (fs, act,IP6_SRC );break ; -case PEDIT_IP6_DST_63_32 : -offload_pedit (fs, val, mask,IP6_DST_63_32 ); +case PEDIT_IP6_DST : +offload_pedit (fs, act,IP6_DST );break ; -case PEDIT_IP6_DST_95_64 : -offload_pedit (fs, val, mask,IP6_DST_95_64 ); -break ; -case PEDIT_IP6_DST_127_96 : -offload_pedit (fs, val, mask,IP6_DST_127_96 ); } fs->nat_mode =NAT_MODE_ALL ;break ;case FLOW_ACT_MANGLE_HDR_TYPE_TCP :switch (offset) { -case PEDIT_TCP_SPORT_DPORT : -if (mask &PEDIT_TCP_UDP_SPORT_MASK ) -offload_pedit (fs,cpu_to_be32 (val) >>16 , -cpu_to_be32 (mask) >>16 , -TCP_SPORT ); -else -offload_pedit (fs,cpu_to_be32 (val), -cpu_to_be32 (mask),TCP_DPORT ); +case PEDIT_TCP_SPORT : +offload_pedit (fs, act,TCP_SPORT ); +break ; +case PEDIT_TCP_DPORT : +offload_pedit (fs, act,TCP_DPORT ); +break ; } fs->nat_mode =NAT_MODE_ALL ;break ;case FLOW_ACT_MANGLE_HDR_TYPE_UDP :switch (offset) { -case PEDIT_UDP_SPORT_DPORT : -if (mask &PEDIT_TCP_UDP_SPORT_MASK ) -offload_pedit (fs,cpu_to_be32 (val) >>16 , -cpu_to_be32 (mask) >>16 , -UDP_SPORT ); -else -offload_pedit (fs,cpu_to_be32 (val), -cpu_to_be32 (mask),UDP_DPORT ); +case PEDIT_UDP_SPORT : +offload_pedit (fs, act,UDP_SPORT ); +break ; +case PEDIT_UDP_DPORT : +offload_pedit (fs, act,UDP_DPORT ); +break ; } fs->nat_mode =NAT_MODE_ALL ; }
@@ -424,17 +392,8 @@ static void cxgb4_process_flow_actions(struct net_device *in, } }break ; -case FLOW_ACTION_MANGLE : { -u32 mask, val, offset; -u8 htype; - - htype = act->mangle.htype; - mask = act->mangle.mask; - val = act->mangle.val; - offset = act->mangle.offset; - -process_pedit_field (fs, val, mask, offset, htype); - } +case FLOW_ACTION_MANGLE : +process_pedit_field (fs, act);break ;default :break ;
@@ -442,35 +401,20 @@ static void cxgb4_process_flow_actions(struct net_device *in, } } -static bool valid_l4_mask (u32 mask) -{ -u16 hi, lo; - -/* Either the upper 16-bits (SPORT) OR the lower -* 16-bits (DPORT) can be set, but NOT BOTH. -*/ - hi = (mask >>16 ) &0xFFFF ; - lo = mask &0xFFFF ; - -return hi && lo ? false : true; -} -static bool valid_pedit_action (struct net_device *dev,const struct flow_action_entry *act) { -u32 mask, offset; +u32 offset;u8 htype; htype = act->mangle.htype; - mask = act->mangle.mask; offset = act->mangle.offset;switch (htype) {case FLOW_ACT_MANGLE_HDR_TYPE_ETH :switch (offset) { -case PEDIT_ETH_DMAC_31_0 : -case PEDIT_ETH_DMAC_47_32_SMAC_15_0 : -case PEDIT_ETH_SMAC_47_16 : +case PEDIT_ETH_DMAC : +case PEDIT_ETH_SMAC :break ;default : netdev_err(dev, "%s: Unsupported pedit field\n",
@@ -491,14 +435,8 @@ static bool valid_pedit_action(struct net_device *dev,break ;case FLOW_ACT_MANGLE_HDR_TYPE_IP6 :switch (offset) { -case PEDIT_IP6_SRC_31_0 : -case PEDIT_IP6_SRC_63_32 : -case PEDIT_IP6_SRC_95_64 : -case PEDIT_IP6_SRC_127_96 : -case PEDIT_IP6_DST_31_0 : -case PEDIT_IP6_DST_63_32 : -case PEDIT_IP6_DST_95_64 : -case PEDIT_IP6_DST_127_96 : +case PEDIT_IP6_SRC : +case PEDIT_IP6_DST :break ;default : netdev_err(dev, "%s: Unsupported pedit field\n",
@@ -508,12 +446,8 @@ static bool valid_pedit_action(struct net_device *dev,break ;case FLOW_ACT_MANGLE_HDR_TYPE_TCP :switch (offset) { -case PEDIT_TCP_SPORT_DPORT : -if (!valid_l4_mask (mask)) { -netdev_err (dev,"%s: Unsupported mask for TCP L4 ports\n" , - __func__); -return false; - } +case PEDIT_TCP_SPORT : +case PEDIT_TCP_DPORT :break ;default : netdev_err(dev, "%s: Unsupported pedit field\n",
@@ -523,12 +457,8 @@ static bool valid_pedit_action(struct net_device *dev,break ;case FLOW_ACT_MANGLE_HDR_TYPE_UDP :switch (offset) { -case PEDIT_UDP_SPORT_DPORT : -if (!valid_l4_mask (mask)) { -netdev_err (dev,"%s: Unsupported mask for UDP L4 ports\n" , - __func__); -return false; - } +case PEDIT_UDP_SPORT : +case PEDIT_UDP_DPORT :break ;default : netdev_err(dev, "%s: Unsupported pedit field\n",
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h +12 -28
@@ -55,23 +55,14 @@ struct ch_tc_flower_entry { };enum { -ETH_DMAC_31_0 ,/* dmac bits 0.. 31 */ -ETH_DMAC_47_32 ,/* dmac bits 32..47 */ -ETH_SMAC_15_0 ,/* smac bits 0.. 15 */ -ETH_SMAC_47_16 ,/* smac bits 16..47 */ +ETH_DMAC ,/* 48-bits dmac bits */ +ETH_SMAC ,/* 48-bits smac bits */ IP4_SRC ,/* 32-bit IPv4 src */ IP4_DST ,/* 32-bit IPv4 dst */ -IP6_SRC_31_0 ,/* src bits 0.. 31 */ -IP6_SRC_63_32 ,/* src bits 63.. 32 */ -IP6_SRC_95_64 ,/* src bits 95.. 64 */ -IP6_SRC_127_96 ,/* src bits 127..96 */ - -IP6_DST_31_0 ,/* dst bits 0.. 31 */ -IP6_DST_63_32 ,/* dst bits 63.. 32 */ -IP6_DST_95_64 ,/* dst bits 95.. 64 */ -IP6_DST_127_96 ,/* dst bits 127..96 */ +IP6_SRC ,/* 128-bit IPv6 src */ +IP6_DST ,/* 128-bit IPv6 dst */ TCP_SPORT ,/* 16-bit TCP sport */ TCP_DPORT ,/* 16-bit TCP dport */
@@ -90,23 +81,16 @@ struct ch_tc_pedit_fields { { type## field, size, \ offsetof(struct ch_filter_specification, fs_field) + (offset) } -#define PEDIT_ETH_DMAC_MASK 0xffff -#define PEDIT_TCP_UDP_SPORT_MASK 0xffff -#define PEDIT_ETH_DMAC_31_0 0x0 -#define PEDIT_ETH_DMAC_47_32_SMAC_15_0 0x4 -#define PEDIT_ETH_SMAC_47_16 0x8 +#define PEDIT_ETH_DMAC 0x0 +#define PEDIT_ETH_SMAC 0x6 +#define PEDIT_IP6_SRC 0x8 +#define PEDIT_IP6_DST 0x18#define PEDIT_IP4_SRC 0xC#define PEDIT_IP4_DST 0x10 -#define PEDIT_IP6_SRC_31_0 0x8 -#define PEDIT_IP6_SRC_63_32 0xC -#define PEDIT_IP6_SRC_95_64 0x10 -#define PEDIT_IP6_SRC_127_96 0x14 -#define PEDIT_IP6_DST_31_0 0x18 -#define PEDIT_IP6_DST_63_32 0x1C -#define PEDIT_IP6_DST_95_64 0x20 -#define PEDIT_IP6_DST_127_96 0x24 -#define PEDIT_TCP_SPORT_DPORT 0x0 -#define PEDIT_UDP_SPORT_DPORT 0x0 +#define PEDIT_TCP_SPORT 0x0 +#define PEDIT_TCP_DPORT 0x2 +#define PEDIT_UDP_SPORT 0x0 +#define PEDIT_UDP_DPORT 0x2int cxgb4_tc_flower_replace (struct net_device *dev,struct flow_cls_offload *cls);
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +26 -54
131 lines not on this page · raw message
drivers/net/ethernet/netronome/nfp/flower/action.c +93 -110
304 lines not on this page · raw message
include/net/flow_offload.h +5 -2
@@ -154,6 +154,8 @@ enum flow_action_mangle_base { FLOW_ACT_MANGLE_HDR_TYPE_UDP, }; +#define FLOW_ACTION_MANGLE_MAXLEN 16 +struct flow_action_entry {enum flow_action_id id;union {
@@ -167,8 +169,9 @@ struct flow_action_entry {struct {/* FLOW_ACTION_PACKET_EDIT */ enum flow_action_mangle_base htype;u32 offset; -u32 mask; -u32 val; +u8 mask[FLOW_ACTION_MANGLE_MAXLEN ]; +u8 val[FLOW_ACTION_MANGLE_MAXLEN ]; +u8 len; } mangle;const struct ip_tunnel_info *tunnel;/* FLOW_ACTION_TUNNEL_ENCAP */ u32 csum_flags;/* FLOW_ACTION_CSUM */
net/sched/cls_api.c +123 -22
168 lines not on this page · raw message
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerPATCH v3 4/4 netfilter: nft_payload: packet mangling offload support
In reply to Pablo Neira AyusoThis patch allows for mangling packet fields using hardware offload infrastructure.
--- net/netfilter/nft_payload.c | 73 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+)
net/netfilter/nft_payload.c +73 -0
@@ -562,12 +562,85 @@ static int nft_payload_set_dump(struct sk_buff *skb, const struct nft_expr *exprreturn -1 ; } +static int nft_payload_offload_set_nh (struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_payload_set *priv) +{ +int type =FLOW_ACT_MANGLE_UNSPEC ; + +switch (ctx->dep.l3num) { +case htons (ETH_P_IP ): + type =FLOW_ACT_MANGLE_HDR_TYPE_IP4 ; +break ; +case htons (ETH_P_IPV6 ): + type =FLOW_ACT_MANGLE_HDR_TYPE_IP6 ; +break ; + } + +return type; +} + +static int nft_payload_offload_set_th (struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_payload_set *priv) +{ +int type =FLOW_ACT_MANGLE_UNSPEC ; + +switch (ctx->dep.protonum) { +case IPPROTO_TCP : + type =FLOW_ACT_MANGLE_HDR_TYPE_TCP ; +break ; +case IPPROTO_UDP : + type =FLOW_ACT_MANGLE_HDR_TYPE_UDP ; +break ; + } + +return type; +} + +static int nft_payload_set_offload (struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_expr *expr) +{ +const struct nft_payload_set *priv =nft_expr_priv (expr); +struct nft_offload_reg *sreg = &ctx->regs[priv->sreg]; +int type =FLOW_ACT_MANGLE_UNSPEC ; +struct flow_action_entry *entry; + +switch (priv->base) { +case NFT_PAYLOAD_LL_HEADER : + type =FLOW_ACT_MANGLE_HDR_TYPE_ETH ; +break ; +case NFT_PAYLOAD_NETWORK_HEADER : + type =nft_payload_offload_set_nh (ctx, flow, priv); +break ; +case NFT_PAYLOAD_TRANSPORT_HEADER : + type =nft_payload_offload_set_th (ctx, flow, priv); +break ; +default : +WARN_ON_ONCE (1 ); +break ; + } + + entry = &flow->rule->action.entries[ctx->num_actions++]; + entry->id =FLOW_ACTION_MANGLE ; + entry->mangle.htype = type; + entry->mangle.offset = priv->offset; + entry->mangle.len = priv->len; + +memcpy (entry->mangle.val, sreg->data.data, priv->len); +memset (entry->mangle.mask,0xff , priv->len); + +return type !=FLOW_ACT_MANGLE_UNSPEC ?0 : -EOPNOTSUPP ; +} +static const struct nft_expr_ops nft_payload_set_ops = { .type = &nft_payload_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_payload_set )), .eval = nft_payload_set_eval, .init = nft_payload_set_init, .dump = nft_payload_set_dump, + .offload = nft_payload_set_offload, }; static const struct nft_expr_ops *
Signature · 1 line
2.11.0
Quoted 32 lines · Pablo Neira Ayuso
This patch updates the mangle action representation:
Patch 1) Undo bitwise NOT operation on the mangle mask (coming from tc
pedit userspace).Patch 2) mangle value &= mask from the front-end side.
Patch 3) adjust offset, length and coalesce consecutive pedit keys into
one single action.Patch 4) add support for payload mangling for netfilter.
After this patchset:
* Offset to payload does not need to be on the 32-bits boundaries anymore. This patchset adds front-end code to adjust the offset and length coming from the tc pedit representation, so drivers get an exact header field offset and length.
* This new front-end code coalesces consecutive pedit actions into one single action, so drivers can mangle IPv6 and ethernet address fields in one go, instead once for each 32-bit word.
On the driver side, diffstat -t shows that drivers code to deal with payload mangling gets simplified:
INSERTED,DELETED,MODIFIED,FILENAME 46,116,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c (-70 LOC) 12,28,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h (-16 LOC) 26,54,0,drivers/net/ethernet/mellanox/mlx5/core/en_tc.c (-27 LOC) 89,111,0,drivers/net/ethernet/netronome/nfp/flower/action.c (-17 LOC)
Quoted 7 lines
While, on the front-end side the balance is the following:
123,22,0,net/sched/cls_api.c (+101 LOC)Changes since v2:
* Fix
is_action_keys_supported()breakage in mlx5 reported by Vlad Buslov.
Still NAK for the same reasons as three versions ago (when it was called "netfilter: payload mangling offload support"), you've never managed to explain why this extra API complexity is useful. (Reducing LOC does not mean you've reduced complexity.)
As Jakub said, 'We suffered through enough haphazard "updates"'. Please can you fix the problems your previous API changes caused (I still haven't had an answer about the flow block changes since sending you my driver code two weeks ago) before trying to ram new ones through.
-Ed
Pablo Neira Ayuso
maintainerQuoted 37 lines · Edward Cree
Quoted 36 lines · Pablo Neira Ayuso
This patch updates the mangle action representation:
Patch 1) Undo bitwise NOT operation on the mangle mask (coming from tc
pedit userspace).Patch 2) mangle value &= mask from the front-end side.
Patch 3) adjust offset, length and coalesce consecutive pedit keys into
one single action.Patch 4) add support for payload mangling for netfilter.
After this patchset:
* Offset to payload does not need to be on the 32-bits boundaries anymore. This patchset adds front-end code to adjust the offset and length coming from the tc pedit representation, so drivers get an exact header field offset and length.
* This new front-end code coalesces consecutive pedit actions into one single action, so drivers can mangle IPv6 and ethernet address fields in one go, instead once for each 32-bit word.
On the driver side, diffstat -t shows that drivers code to deal with payload mangling gets simplified:
INSERTED,DELETED,MODIFIED,FILENAME 46,116,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c (-70 LOC) 12,28,0,drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.h (-16 LOC) 26,54,0,drivers/net/ethernet/mellanox/mlx5/core/en_tc.c (-27 LOC) 89,111,0,drivers/net/ethernet/netronome/nfp/flower/action.c (-17 LOC)While, on the front-end side the balance is the following:
123,22,0,net/sched/cls_api.c (+101 LOC)
Quoted 8 lines
Quoted 3 lines
Changes since v2:
* Fix
is_action_keys_supported()breakage in mlx5 reported by Vlad Buslov.Still NAK for the same reasons as three versions ago (when it was called "netfilter: payload mangling offload support"), you've never managed to explain why this extra API complexity is useful. (Reducing LOC does not mean you've reduced complexity.)
Oh well...
Patch 1) Mask is inverted for no reason, just because tc pedit needs this in this way. All drivers reverse this mask.
Patch 2) All drivers mask out meaningless fields in the value field.
Patch 3) Without this patchset, offsets are on the 32-bit boundary. Drivers need to play with the 32-bit mask to infer what field they are supposed to mangle... eg. with 32-bit offset alignment, checking if the use want to alter the ttl/hop_limit need for helper structures to check the 32-bit mask. Mangling a IPv6 address comes with one single action...
Quoted 11 lines · Pablo Neira Ayuso
Quoted 4 lines · Edward Cree
Still NAK for the same reasons as three versions ago (when it was called "netfilter: payload mangling offload support"), you've never managed to explain why this extra API complexity is useful. (Reducing LOC does not mean you've reduced complexity.)
Oh well...
Patch 1) Mask is inverted for no reason, just because tc pedit needs this in this way. All drivers reverse this mask.
Patch 2) All drivers mask out meaningless fields in the value field.
To be clear: I have no issue with these two patches; they look fine to me. (Though I'd like to see some comments on struct flow_action_entry specifying the semantics of these fields, especially if they're going to differ from the corresponding fields in struct tc_pedit_key.)
Quoted 6 lines
Patch 3) Without this patchset, offsets are on the 32-bit boundary. Drivers need to play with the 32-bit mask to infer what field they are supposed to mangle... eg. with 32-bit offset alignment, checking if the use want to alter the ttl/hop_limit need for helper structures to check the 32-bit mask. Mangling a IPv6 address comes with one single action...
Drivers are still going to need to handle multiple pedit actions, in case the original rule wanted to mangle two non-consecutive fields. And you can't just coalesce all consecutive mangles, because if you mangle two consecutive fields (e.g. UDP sport and dport) the driver still needs to disentangle that if it works on a 'fields' (rather than 'u32s') level.
So either have the core convert things into named protocol fields (i.e. "set src IPv6 to 1234::5 and add 1 to UDP sport"), or leave the current sequence-of-u32-mangles as it is. This in-between "we'll coalesce things together despite not knowing what fields they are" is neither fish nor fowl.
-Ed
Pablo Neira Ayuso
maintainerQuoted 11 lines · Edward Cree
Quoted 10 lines · Pablo Neira Ayuso
Quoted 4 lines · Edward Cree
Still NAK for the same reasons as three versions ago (when it was called "netfilter: payload mangling offload support"), you've never managed to explain why this extra API complexity is useful. (Reducing LOC does not mean you've reduced complexity.)
Oh well...
Patch 1) Mask is inverted for no reason, just because tc pedit needs this in this way. All drivers reverse this mask.
Quoted 6 lines
Quoted 1 line
Patch 2) All drivers mask out meaningless fields in the value field.
To be clear: I have no issue with these two patches; they look fine to me. (Though I'd like to see some comments on struct
flow_action_entryspecifying the semantics of these fields, especially if they're going to differ from the corresponding fields in structtc_pedit_key.)
OK, I can document this semantics, I need just _time_ to write that documentation. I was expecting this patch description is enough by now until I can get to finish that documentation.
Quoted 7 lines
Quoted 6 lines
Patch 3) Without this patchset, offsets are on the 32-bit boundary. Drivers need to play with the 32-bit mask to infer what field they are supposed to mangle... eg. with 32-bit offset alignment, checking if the use want to alter the ttl/hop_limit need for helper structures to check the 32-bit mask. Mangling a IPv6 address comes with one single action...
Quoted 6 lines
Drivers are still going to need to handle multiple pedit actions, in case the original rule wanted to mangle two non-consecutive fields. And you can't just coalesce all consecutive mangles, because if you mangle two consecutive fields (e.g. UDP sport and dport) the driver still needs to disentangle that if it works on a 'fields' (rather than 'u32s') level.
This infrastructure is _not_ coalescing two consecutive field, e.g. UDP sport and dport is _not_ coalesced. The coalesce routine does _not_ handle multiple tc pedit ex actions.
I'll clarify this in the cover letter in the next patchset round.
Quoted 5 lines
So either have the core convert things into named protocol fields
(i.e. "set src IPv6 to 1234::5 and add 1 to UDP sport"), or leave the current sequence-of-u32-mangles as it is. This in-between "we'll coalesce things together despite not knowing what fields they are" is neither fish nor fowl.
The model you propose would still need this code for tc pedit to adjust offset/length and coalesce u32 fields.
Quoted 3 lines · Pablo Neira Ayuso
OK, I can document this semantics, I need just _time_ to write that documentation. I was expecting this patch description is enough by now until I can get to finish that documentation.
I think for two structs with apparently the same contents but different semantics (one has the mask bitwise complemented) it's best to hold up the code change until the comment is ready to come with it, because until then it's a dangerously confusing situation.
Quoted 7 lines
Quoted 4 lines
And you can't just coalesce all consecutive mangles, because if you mangle two consecutive fields (e.g. UDP sport and dport) the driver still needs to disentangle that if it works on a 'fields' (rather than 'u32s') level.
This infrastructure is _not_ coalescing two consecutive field, e.g. UDP sport and dport is _not_ coalesced. The coalesce routine does _not_ handle multiple tc pedit ex actions.
So an IPv6 address mangle only comes as a single action if it's from netfilter, not if it's coming from TC pedit. Therefore drivers still need to handle an IPv6 or MAC address mangle coming in multiple actions, therefore your driver simplifications are invalid. No?
Quoted 2 lines
The model you propose would still need this code for tc pedit to adjust offset/length and coalesce u32 fields.
Yes, but we don't add code/features to the kernel based on what we *could* use it for later; every submission has to be self-contained in providing something of demonstrable value. So either implement "the model I propose" (which to be clear I'm *not* proposing, I want the u32 pedit left as it is; it's just that it's a better model than what you're implementing here), or leave well alone.
-Ed
Pablo Neira Ayuso
maintainerQuoted 9 lines · Edward Cree
Quoted 3 lines · Pablo Neira Ayuso
OK, I can document this semantics, I need just _time_ to write that documentation. I was expecting this patch description is enough by now until I can get to finish that documentation.
I think for two structs with apparently the same contents but different semantics (one has the mask bitwise complemented) it's best to hold up the code change until the comment is ready to come with it, because until then it's a dangerously confusing situation.
The idea is that flow rule API != tc front-end anymore. So the flow rule API can evolve regardless the front-end requirements. Before this update there was no other choice than using the tc pedit layout since it was exposed to the drivers, this is not the case anymore.
Quoted 11 lines
Quoted 8 lines
Quoted 4 lines
And you can't just coalesce all consecutive mangles, because if you mangle two consecutive fields (e.g. UDP sport and dport) the driver still needs to disentangle that if it works on a 'fields' (rather than 'u32s') level.
This infrastructure is _not_ coalescing two consecutive field, e.g. UDP sport and dport is _not_ coalesced. The coalesce routine does _not_ handle multiple tc pedit ex actions.
So an IPv6 address mangle only comes as a single action if it's from netfilter, not if it's coming from TC pedit.
Driver gets one single action from tc/netfilter (and potentially ethtool if it would support for this), it comes as a single action from both subsystems:
front-end -----> flow_rule API -----> drivers
Front-end need to translate their representation to this FLOW_ACTION_MANGLE layout.
By front-end, I refer to ethtool/netfilter/tc.
Quoted 3 lines
Therefore drivers still need to handle an IPv6 or MAC address mangle coming in multiple actions, therefore your driver simplifications are invalid. No?
No. IPv6 and MAC come as a single action. All subsystems use the same flow_rule API, they use the same layout.
Quoted 5 lines
Quoted 2 lines
The model you propose would still need this code for tc pedit to adjust offset/length and coalesce u32 fields.
Yes, but we don't add code/features to the kernel based on what we
*could* use it for later
This is already useful: Look at the cxgb driver in particular, it's way easier to read.
Other existing drivers do not need to do things like:
case round_down(offsetof(struct iphdr, tos), 4):
and the play with masks to infer if the user wants to mangle the TOS field, they can just do:
case offsetof(struct iphdr, tos):
which is way more natural representation.
Quoted 5 lines · Pablo Neira Ayuso
Quoted 4 lines · Edward Cree
Quoted 3 lines · Pablo Neira Ayuso
OK, I can document this semantics, I need just _time_ to write that documentation. I was expecting this patch description is enough by now until I can get to finish that documentation.
Quoted 8 lines
Quoted 4 lines
I think for two structs with apparently the same contents but different semantics (one has the mask bitwise complemented) it's best to hold up the code change until the comment is ready to come with it, because until then it's a dangerously confusing situation.
The idea is that flow rule API != tc front-end anymore. So the flow rule API can evolve regardless the front-end requirements. Before this update there was no other choice than using the tc pedit layout since it was exposed to the drivers, this is not the case anymore.
I'm not saying that they have to be the same.
I'm saying that they're _almost_ the same, and having things that are _almost_ the same but subtly different is a recipe for misunderstandings and bugs, and so must must must have very visible comments in the code.
Quoted 6 lines
Quoted 2 lines
So an IPv6 address mangle only comes as a single action if it's from netfilter, not if it's coming from TC pedit.
Driver gets one single action from tc/netfilter (and potentially ethtool if it would support for this), it comes as a single action from both subsystems:
Quoted 6 lines
front-end -----> flow_rule API -----> driversFront-end need to translate their representation to this
FLOW_ACTION_MANGLElayout.By front-end, I refer to ethtool/netfilter/tc.
In your patch, flow_action_mangle() looks only at the offset and type (add vs. set) of each pedit, coalesces them if compatible (so, unless I'm misreading the code, it _will_ coalesce adjacent pedits to contiguous fields like UDP sport & dport, unlike what you said), because it doesn't know whether two contiguous pedits are part of the same field or not (it doesn't have any knowledge of 'fields' at all). And for you to change that, while still coalescing IPv6 pedits, you would need flow_action_mangle() to know what fields each pedit is in. It is not possible for code that doesn't know about fields to both:
(a) not coalesce edits of contiguous fields, and
(b) coalesce edits of larger-than-u32 fields
Quoted 4 lines
Quoted 2 lines
Yes, but we don't add code/features to the kernel based on what we
*could* use it for laterThis is already useful: Look at the cxgb driver in particular, it's way easier to read.
Have you tested it? Again, I might be misreading, but it looks like your flow_action_mangle() *will* coalesce sport & dport, which it appears will break that cxgb code.
Quoted 10 lines
Other existing drivers do not need to do things like:
case
round_down(offsetof(struct iphdr, tos), 4):and the play with masks to infer if the user wants to mangle the TOS field, they can just do:
case
offsetof(struct iphdr, tos):which is way more natural representation.
Proper thing to do is have helper functions available to drivers to test the pedit, and not just switch on the offset. Why do I say that? Well, consider a pedit on UDP dport, with mask 0x00ff (network endian). Now as a u32 pedit that's 0x000000ff offset 0, so field-blind offset calculation (ffs in flow_action_mangle_entry()) will turn that into offset 3 mask 0xff. Now driver does
switch(offset) { /* 3 */
case offsetof(struct udphdr, dest): /* 2 */
/* Whoops, we never get here! */
}
Do you see the problem?
-Ed
Pablo Neira Ayuso
maintainerHi Edward,
Quoted 2 lines · Edward Cree
Quoted 1 line · Pablo Neira Ayuso
On Fri, Sep 06, 2019 at 02:37:16PM +0100, Edward Cree wrote:
[...]
Quoted 11 lines
Quoted 11 lines
Quoted 2 lines
So an IPv6 address mangle only comes as a single action if it's from netfilter, not if it's coming from TC pedit.
Driver gets one single action from tc/netfilter (and potentially ethtool if it would support for this), it comes as a single action from both subsystems:
front-end -----> flow_rule API -----> driversFront-end need to translate their representation to this
FLOW_ACTION_MANGLElayout.
Quoted 8 lines
Quoted 1 line
By front-end, I refer to ethtool/netfilter/tc.
In your patch,
flow_action_mangle()looks only at the offset and type
(add vs. set) of each pedit, coalesces them if compatible (so, unless I'm misreading the code, it _will_ coalesce adjacent pedits to contiguous fields like UDP sport & dport, unlike what you said), because it doesn't know whether two contiguous pedits are part of the same field or not (it doesn't have any knowledge of 'fields' at all).
In tc pedit ex, those are _indeed_ two separated actions:
* One to mangle UDP sport.
* One to mangle UDP dport.
They are _not_ one as you describe above.
The coalesce routine I made does _not_ coalesce fields in two different actions.
Quoted 2 lines
And for you to change that, while still coalescing IPv6 pedits, you
would needflow_action_mangle()to know what fields each pedit is in.
In the particular case of IPv6 address, 'tc pedit ex' generates one single action with 4 nkeys. So this is:
* One action to mangle four 32-bits words (the number of words in tc pedit is stored in the nkeys field).
The coalesce routine I made in this case merges the four 32-bits words into one single action.
[...]
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
Yes, but we don't add code/features to the kernel based on what we
*could* use it for laterThis is already useful: Look at the cxgb driver in particular, it's way easier to read.
Have you tested it? Again, I might be misreading, but it looks like
yourflow_action_mangle()*will* coalesce sport & dport, which it appears will break that cxgb code.
Because sport and dport are not place in the same action by tc pedit ex, _that cannot happen_.
Quoted 23 lines
Quoted 10 lines
Other existing drivers do not need to do things like:
case
round_down(offsetof(struct iphdr, tos), 4):and the play with masks to infer if the user wants to mangle the TOS field, they can just do:
case
offsetof(struct iphdr, tos):which is way more natural representation.
Proper thing to do is have helper functions available to drivers to test the pedit, and not just switch on the offset. Why do I say that?
Well, consider a pedit on UDP dport, with mask
0x00ff(network endian). Now as a u32 pedit that's0x000000ffoffset 0, so field-blind offset calculation (ffs inflow_action_mangle_entry()) will turn that into offset 3 mask 0xff. Now driver does
switch(offset) { /* 3 */
caseoffsetof(struct udphdr, dest): /* 2 */
/* Whoops, we never get here! */
}
Quoted 1 line
Do you see the problem?
This scenario you describe cannot _work_ right now, with the existing code. Without my patchset, this scenario you describe does _not_ work,
The drivers in the tree need a mask of 0xffff to infer that this is UDP dport.
The 'tc pedit ex' infrastructure does not allow for the scenario that you describe above.
No driver in the tree allow for what you describe already.
Quoted 1 line · Pablo Neira Ayuso
In tc pedit ex, those are _indeed_ two separated actions:
I read the code again and I get it now, there's double iteration already over tcf_exts_for_each_action and tcf_pedit_nkeys, and it's only within the latter that you coalesce.
However, have you considered that iproute2 (i.e. tc tool) isn't guaranteed to be the only userland consumer of the TC uAPI? For all we know there could be another user out there producing things like a single pedit action with two keys, same offset but different masks, to mangle sport & dport separately, which your code now _would_ coalesce into a single mangle. I don't know if that would lead to any problems, but I want to be sure you've thought about it ;)
Quoted 16 lines
Quoted 12 lines
Proper thing to do is have helper functions available to drivers to test the pedit, and not just switch on the offset. Why do I say that?
Well, consider a pedit on UDP dport, with mask
0x00ff(network endian). Now as a u32 pedit that's0x000000ffoffset 0, so field-blind offset calculation (ffs inflow_action_mangle_entry()) will turn that into offset 3 mask 0xff. Now driver does
switch(offset) { /* 3 */
caseoffsetof(struct udphdr, dest): /* 2 */
/* Whoops, we never get here! */
}Quoted 1 line
Do you see the problem?
This scenario you describe cannot _work_ right now, with the existing code. Without my patchset, this scenario you describe does _not_ work,
Quoted 7 lines
The drivers in the tree need a mask of
0xffffto infer that this is UDP dport.The 'tc pedit ex' infrastructure does not allow for the scenario that you describe above.
No driver in the tree allow for what you describe already.
Looks to me like existing nfp_fl_set_tport() handles just fine any arbitrary mask across the u32 that contains UDP sport & dport. And the uAPI we have to maintain is the uAPI we expose, not the subset that iproute2 uses. I could write a patched tc tool *today* that does a pedit of 'UDP header, offset 0, mask 0xff0000ff' and the nfp driver would accept that fine (no idea what the fw / chip would do with it, but presumably it works or Netronome folks would have put checks in), whereas with your patch it'll complain "invalid pedit L4 action" because the mask isn't all-1s.
And if I made it produce my example from above, mask 0x000000ff, you'd calculate an offset of 3 and hit the other error, "unsupported section of L4 header", which again would have worked before.
Pablo Neira Ayuso
maintainerQuoted 6 lines · Edward Cree
Quoted 1 line · Pablo Neira Ayuso
In tc pedit ex, those are _indeed_ two separated actions:
I read the code again and I get it now, there's double iteration
already overtcf_exts_for_each_actionandtcf_pedit_nkeys, and it's only within the latter that you coalesce.
Exactly.
Quoted 7 lines
However, have you considered that iproute2 (i.e. tc tool) isn't
guaranteed to be the only userland consumer of the TC uAPI?
For all we know there could be another user out there producing things like
a single pedit action with two keys, same offset but different masks, to mangle sport & dport separately, which your code now _would_ coalesce into a single mangle. I don't know if that would lead to any problems, but I want to be sure you've thought about it ;)
tc pedit only supports for the "extended mode". So the hardware offloads only support for a subset of the tc pedit uAPI already.
Userland may decide not to use the "extended mode", however, it will not work for hardware offloads.
Quoted 25 lines
Quoted 17 lines
Quoted 12 lines
Proper thing to do is have helper functions available to drivers to test the pedit, and not just switch on the offset. Why do I say that?
Well, consider a pedit on UDP dport, with mask
0x00ff(network endian). Now as a u32 pedit that's0x000000ffoffset 0, so field-blind offset calculation (ffs inflow_action_mangle_entry()) will turn that into offset 3 mask 0xff. Now driver does
switch(offset) { /* 3 */
caseoffsetof(struct udphdr, dest): /* 2 */
/* Whoops, we never get here! */
}Quoted 1 line
Do you see the problem?
This scenario you describe cannot _work_ right now, with the existing code. Without my patchset, this scenario you describe does _not_ work,
Quoted 7 lines
The drivers in the tree need a mask of
0xffffto infer that this is UDP dport.The 'tc pedit ex' infrastructure does not allow for the scenario that you describe above.
No driver in the tree allow for what you describe already.
Quoted 9 lines
Looks to me like existing
nfp_fl_set_tport()handles just fine any
arbitrary mask across the u32 that contains UDP sport & dport.
And the uAPI we have to maintain is the uAPI we expose, not the subset
that iproute2 uses. I could write a patched tc tool *today* that does a pedit of 'UDP header, offset 0, mask0xff0000ff' and the nfp driver would accept that fine (no idea what the fw / chip would do with it, but presumably it works or Netronome folks would have put checks in), whereas with your patch it'll complain "invalid pedit L4 action" because the mask isn't all-1s.
'UDP header, offset 0, mask 0xff0000ff': Mangle one byte of the UDP sport, and only one mangle of the dport via uAPI.
I get your point: If you think that supporting for this is reasonable usecase, I'll fix this patchset and send a v4 so the nfp still works for this.
Quoted 3 lines
And if I made it produce my example from above, mask
0x000000ff, you'd
calculate an offset of 3 and hit the other error, "unsupported section of L4 header", which again would have worked before.
'mask 0x000000ff' mangle only one byte of a UDP port.
I'm sorry for this, I assumed in this case that the reasonable (sane) uAPI subset in this case to be supported for the hardware offloads is what tc tool via pedit ex generates.
I'll restore the nfp driver so it works for these scenarios via uAPI that you describe.