target/linux/generic/backport-6.1/600-v6.9-01-net-gro-parse-ipv6-ext-headers-without-frag0-invalid.patch

   1 From: Richard Gobert <richardbgobert@gmail.com>
   2 Date: Wed, 3 Jan 2024 15:44:21 +0100
   3 Subject: [PATCH] net: gro: parse ipv6 ext headers without frag0 invalidation
   4
   5 The existing code always pulls the IPv6 header and sets the transport
   6 offset initially. Then optionally again pulls any extension headers in
   7 ipv6_gso_pull_exthdrs and sets the transport offset again on return from
   8 that call. skb->data is set at the start of the first extension header
   9 before calling ipv6_gso_pull_exthdrs, and must disable the frag0
  10 optimization because that function uses pskb_may_pull/pskb_pull instead of
  11 skb_gro_ helpers. It sets the GRO offset to the TCP header with
  12 skb_gro_pull and sets the transport header. Then returns skb->data to its
  13 position before this block.
  14
  15 This commit introduces a new helper function - ipv6_gro_pull_exthdrs -
  16 which is used in ipv6_gro_receive to pull ipv6 ext headers instead of
  17 ipv6_gso_pull_exthdrs. Thus, there is no modification of skb->data, all
  18 operations use skb_gro_* helpers, and the frag0 fast path can be taken for
  19 IPv6 packets with ext headers.
  20
  21 Signed-off-by: Richard Gobert <richardbgobert@gmail.com>
  22 Reviewed-by: Willem de Bruijn <willemb@google.com>
  23 Reviewed-by: David Ahern <dsahern@kernel.org>
  24 Reviewed-by: Eric Dumazet <edumazet@google.com>
  25 Link: https://lore.kernel.org/r/504130f6-b56c-4dcc-882c-97942c59f5b7@gmail.com
  26 Signed-off-by: Jakub Kicinski <kuba@kernel.org>
  27 ---
  28
  29 --- a/net/ipv6/ip6_offload.c
  30 +++ b/net/ipv6/ip6_offload.c
  31 @@ -36,6 +36,40 @@
  32                 INDIRECT_CALL_L4(cb, f2, f1, head, skb);        \
  33  })
  34
  35 +static int ipv6_gro_pull_exthdrs(struct sk_buff *skb, int off, int proto)
  36 +{
  37 +       const struct net_offload *ops = NULL;
  38 +       struct ipv6_opt_hdr *opth;
  39 +
  40 +       for (;;) {
  41 +               int len;
  42 +
  43 +               ops = rcu_dereference(inet6_offloads[proto]);
  44 +
  45 +               if (unlikely(!ops))
  46 +                       break;
  47 +
  48 +               if (!(ops->flags & INET6_PROTO_GSO_EXTHDR))
  49 +                       break;
  50 +
  51 +               opth = skb_gro_header(skb, off + sizeof(*opth), off);
  52 +               if (unlikely(!opth))
  53 +                       break;
  54 +
  55 +               len = ipv6_optlen(opth);
  56 +
  57 +               opth = skb_gro_header(skb, off + len, off);
  58 +               if (unlikely(!opth))
  59 +                       break;
  60 +               proto = opth->nexthdr;
  61 +
  62 +               off += len;
  63 +       }
  64 +
  65 +       skb_gro_pull(skb, off - skb_network_offset(skb));
  66 +       return proto;
  67 +}
  68 +
  69  static int ipv6_gso_pull_exthdrs(struct sk_buff *skb, int proto)
  70  {
  71         const struct net_offload *ops = NULL;
  72 @@ -224,28 +258,25 @@ INDIRECT_CALLABLE_SCOPE struct sk_buff *
  73                 goto out;
  74
  75         skb_set_network_header(skb, off);
  76 -       skb_gro_pull(skb, sizeof(*iph));
  77 -       skb_set_transport_header(skb, skb_gro_offset(skb));
  78
  79 -       flush += ntohs(iph->payload_len) != skb_gro_len(skb);
  80 +       flush += ntohs(iph->payload_len) != skb->len - hlen;
  81
  82         proto = iph->nexthdr;
  83         ops = rcu_dereference(inet6_offloads[proto]);
  84         if (!ops || !ops->callbacks.gro_receive) {
  85 -               pskb_pull(skb, skb_gro_offset(skb));
  86 -               skb_gro_frag0_invalidate(skb);
  87 -               proto = ipv6_gso_pull_exthdrs(skb, proto);
  88 -               skb_gro_pull(skb, -skb_transport_offset(skb));
  89 -               skb_reset_transport_header(skb);
  90 -               __skb_push(skb, skb_gro_offset(skb));
  91 +               proto = ipv6_gro_pull_exthdrs(skb, hlen, proto);
  92
  93                 ops = rcu_dereference(inet6_offloads[proto]);
  94                 if (!ops || !ops->callbacks.gro_receive)
  95                         goto out;
  96
  97 -               iph = ipv6_hdr(skb);
  98 +               iph = skb_gro_network_header(skb);
  99 +       } else {
 100 +               skb_gro_pull(skb, sizeof(*iph));
 101         }
 102
 103 +       skb_set_transport_header(skb, skb_gro_offset(skb));
 104 +
 105         NAPI_GRO_CB(skb)->proto = proto;
 106
 107         flush--;