PSP socket support has thus far been limited to TCP, and psp_dev_encapsulate() hardcodes IPPROTO_TCP as the PSP next header. Socket-less PSP associations will also support UDP traffic. Populate the PSP next header from the IP header of the original packet instead. With the next header taken from the fixed header, psp_dev_encapsulate() now refuses some cases which are unsupported: - IPv4 and IPv6 fragments. Non-initial fragments have no L4 header, so this cannot work. Not a behavior change for PSP sockets. - IPv6 extension headers. More generally, any packet whose transport header isn't right after the fixed IP header. Some of these could be supported in the future. Not a behavior change for PSP sockets. - Already encapsulated for a tunnel (skb->encapsulation). Their inner headers are already set up. Both callers of psp_dev_encapsulate(), mlx5 and netdevsim, drop the packet when it returns false. mlx5e also fixes up the TCP checksum of GSO skbs for the device, which is only valid for TCP. Have the stack segment other GSO skbs, e.g. UDP from socket-less associations, in software. Likewise the device only completes a TCP or UDP checksum behind the PSP header: have the stack checksum the other CHECKSUM_PARTIAL skbs. For the outer UDP source port, psp_write_headers() already branches to use TCP ehash if the skb has a socket, with fallback to udp_flow_src_port(). Previously, sk always meant TCP. Add an explicit check on nexthdr, and on the socket being a TCP one (a raw or packet socket can send TCP segments, and has no sk_hash), so that the fallback branch is taken for other packets. udp_flow_src_port() hashes the flow if the skb has no hash yet: compute it in psp_dev_encapsulate() before the headers are moved and the IP protocol rewritten, so that it covers the packet's own flow rather than the outer headers being written. Signed-off-by: Todd Freed --- .../net/ethernet/mellanox/mlx5/core/en_main.c | 33 +++++++++++ net/psp/psp_main.c | 56 +++++++++++++++---- 2 files changed, 79 insertions(+), 10 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index 2be8147fdb64..d6c32080634d 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -5139,6 +5139,23 @@ static netdev_features_t mlx5e_tunnel_features_check(struct mlx5e_priv *priv, return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); } +/* The L4 protocol right after the fixed IP header, which the PSP Tx path + * requires, is one the device can complete the checksum of + */ +static bool mlx5e_psp_l4_csum_ok(const struct sk_buff *skb) +{ + u8 proto; + + if (skb->protocol == htons(ETH_P_IP)) + proto = ip_hdr(skb)->protocol; + else if (skb->protocol == htons(ETH_P_IPV6)) + proto = ipv6_hdr(skb)->nexthdr; + else + return false; + + return proto == IPPROTO_TCP || proto == IPPROTO_UDP; +} + netdev_features_t mlx5e_features_check(struct sk_buff *skb, struct net_device *netdev, netdev_features_t features) @@ -5147,6 +5164,22 @@ netdev_features_t mlx5e_features_check(struct sk_buff *skb, features = vlan_features_check(skb, features); + /* The PSP tx path fixes up the TCP checksum of a GSO skb for the + * device, which is only valid for TCP, and the device only completes + * a TCP or UDP checksum behind the PSP header. Have the stack segment + * and checksum other skbs. + */ + if ((skb_is_gso(skb) || skb->ip_summed == CHECKSUM_PARTIAL) && + mlx5e_psp_is_offload(skb, netdev)) { + if (skb_is_gso(skb) && + !(skb_shinfo(skb)->gso_type & + (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) + features &= ~NETIF_F_GSO_MASK; + if (skb->ip_summed == CHECKSUM_PARTIAL && + !mlx5e_psp_l4_csum_ok(skb)) + features &= ~NETIF_F_CSUM_MASK; + } + /* Validate if the tunneled packet is being offloaded by HW */ if (skb->encapsulation && (features & NETIF_F_CSUM_MASK || features & NETIF_F_GSO_MASK)) diff --git a/net/psp/psp_main.c b/net/psp/psp_main.c index e09f6fec948d..4b48070fb9e5 100644 --- a/net/psp/psp_main.c +++ b/net/psp/psp_main.c @@ -189,7 +189,8 @@ unsigned int psp_key_size(u32 version) EXPORT_SYMBOL(psp_key_size); static void psp_write_headers(struct net *net, struct sk_buff *skb, __be32 spi, - u8 ver, unsigned int udp_len, __be16 sport) + u8 ver, u8 nexthdr, unsigned int udp_len, + __be16 sport) { struct udphdr *uh = udp_hdr(skb); struct psphdr *psph = (struct psphdr *)(uh + 1); @@ -211,10 +212,11 @@ static void psp_write_headers(struct net *net, struct sk_buff *skb, __be32 spi, * This field is subject to reshuffling, thanks to * sk_rethink_txhash() calls in various TCP functions. * - * Instead, use sk->sk_hash which is constant through + * Instead, use sk->sk_hash for TCP which is constant through * the whole flow duration. */ - if (likely(sk)) { + if (likely(sk && nexthdr == IPPROTO_TCP && + (!sk_fullsock(sk) || sk_is_tcp(sk)))) { u32 hash = sk->sk_hash; int min, max; @@ -236,7 +238,7 @@ static void psp_write_headers(struct net *net, struct sk_buff *skb, __be32 spi, uh->check = 0; udp_set_len(uh, udp_len); - psph->nexthdr = IPPROTO_TCP; + psph->nexthdr = nexthdr; psph->hdrlen = PSP_HDRLEN_NOOPT; psph->crypt_offset = 0; psph->verfl = FIELD_PREP(PSPHDR_VERFL_VERSION, ver) | @@ -245,8 +247,32 @@ static void psp_write_headers(struct net *net, struct sk_buff *skb, __be32 spi, memset(&psph->iv, 0, sizeof(psph->iv)); } -/* Encapsulate a TCP packet with PSP by adding the UDP+PSP headers and filling - * them in. +/* UDP+PSP goes in at the transport header, the protocol of the fixed IP + * header becomes UDP, and the PSP next header takes the protocol it had. The + * transport header must directly follow the fixed header. + */ +static bool psp_dev_encap_ok(const struct sk_buff *skb) +{ + u32 network_len = skb_network_header_len(skb); + + /* inner headers already set up */ + if (skb->encapsulation) + return false; + /* fragments not supported for transport mode */ + if (skb->protocol == htons(ETH_P_IP)) + return network_len == ip_hdrlen(skb) && + !ip_is_fragment(ip_hdr(skb)); + if (skb->protocol == htons(ETH_P_IPV6)) + return !ipv6_ext_hdr(ipv6_hdr(skb)->nexthdr) && + network_len == sizeof(struct ipv6hdr); + return false; +} + +/* Encapsulate a packet with PSP by adding the UDP+PSP headers and filling + * them in. The PSP next header is taken from the IP header: packets with + * IPv6 extension headers, or whose transport header isn't right after the IP + * header, are refused, as are IP fragments and packets already + * encapsulated for a tunnel. */ bool psp_dev_encapsulate(struct net *net, struct sk_buff *skb, __be32 spi, u8 ver, __be16 sport) @@ -254,11 +280,21 @@ bool psp_dev_encapsulate(struct net *net, struct sk_buff *skb, __be32 spi, u32 network_len = skb_network_header_len(skb); u32 ethr_len = skb_mac_header_len(skb); u32 bufflen = ethr_len + network_len; + u8 nexthdr; - if (skb->protocol != htons(ETH_P_IP) && - skb->protocol != htons(ETH_P_IPV6)) + if (!psp_dev_encap_ok(skb)) return false; + if (skb->protocol == htons(ETH_P_IP)) + nexthdr = ip_hdr(skb)->protocol; + else + nexthdr = ipv6_hdr(skb)->nexthdr; + + /* udp_flow_src_port() may need to hash the flow: do it on the + * original headers, before they are moved and rewritten + */ + skb_get_hash(skb); + if (skb_cow_head(skb, PSP_ENCAP_HLEN)) return false; @@ -279,11 +315,11 @@ bool psp_dev_encapsulate(struct net *net, struct sk_buff *skb, __be32 spi, be16_add_cpu(&ipv6_hdr(skb)->payload_len, PSP_ENCAP_HLEN); } - skb_set_inner_ipproto(skb, IPPROTO_TCP); + skb_set_inner_ipproto(skb, nexthdr); skb_set_inner_transport_header(skb, skb_transport_offset(skb) + PSP_ENCAP_HLEN); skb->encapsulation = 1; - psp_write_headers(net, skb, spi, ver, + psp_write_headers(net, skb, spi, ver, nexthdr, skb->len - skb_transport_offset(skb), sport); return true; -- 2.53.1-Meta