Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *      IPV6 GSO/GRO offload support
       4                 :            :  *      Linux INET6 implementation
       5                 :            :  *
       6                 :            :  *      UDPv6 GSO support
       7                 :            :  */
       8                 :            : #include <linux/skbuff.h>
       9                 :            : #include <linux/netdevice.h>
      10                 :            : #include <linux/indirect_call_wrapper.h>
      11                 :            : #include <net/protocol.h>
      12                 :            : #include <net/ipv6.h>
      13                 :            : #include <net/udp.h>
      14                 :            : #include <net/ip6_checksum.h>
      15                 :            : #include "ip6_offload.h"
      16                 :            : 
      17                 :          0 : static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb,
      18                 :            :                                          netdev_features_t features)
      19                 :            : {
      20                 :            :         struct sk_buff *segs = ERR_PTR(-EINVAL);
      21                 :            :         unsigned int mss;
      22                 :            :         unsigned int unfrag_ip6hlen, unfrag_len;
      23                 :            :         struct frag_hdr *fptr;
      24                 :            :         u8 *packet_start, *prevhdr;
      25                 :            :         u8 nexthdr;
      26                 :            :         u8 frag_hdr_sz = sizeof(struct frag_hdr);
      27                 :            :         __wsum csum;
      28                 :            :         int tnl_hlen;
      29                 :            :         int err;
      30                 :            : 
      31                 :          0 :         mss = skb_shinfo(skb)->gso_size;
      32                 :          0 :         if (unlikely(skb->len <= mss))
      33                 :            :                 goto out;
      34                 :            : 
      35                 :          0 :         if (skb->encapsulation && skb_shinfo(skb)->gso_type &
      36                 :            :             (SKB_GSO_UDP_TUNNEL|SKB_GSO_UDP_TUNNEL_CSUM))
      37                 :          0 :                 segs = skb_udp_tunnel_segment(skb, features, true);
      38                 :            :         else {
      39                 :            :                 const struct ipv6hdr *ipv6h;
      40                 :            :                 struct udphdr *uh;
      41                 :            : 
      42                 :          0 :                 if (!(skb_shinfo(skb)->gso_type & (SKB_GSO_UDP | SKB_GSO_UDP_L4)))
      43                 :            :                         goto out;
      44                 :            : 
      45                 :          0 :                 if (!pskb_may_pull(skb, sizeof(struct udphdr)))
      46                 :            :                         goto out;
      47                 :            : 
      48                 :          0 :                 if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4)
      49                 :          0 :                         return __udp_gso_segment(skb, features);
      50                 :            : 
      51                 :            :                 /* Do software UFO. Complete and fill in the UDP checksum as HW cannot
      52                 :            :                  * do checksum of UDP packets sent as multiple IP fragments.
      53                 :            :                  */
      54                 :            : 
      55                 :            :                 uh = udp_hdr(skb);
      56                 :            :                 ipv6h = ipv6_hdr(skb);
      57                 :            : 
      58                 :          0 :                 uh->check = 0;
      59                 :          0 :                 csum = skb_checksum(skb, 0, skb->len, 0);
      60                 :          0 :                 uh->check = udp_v6_check(skb->len, &ipv6h->saddr,
      61                 :            :                                           &ipv6h->daddr, csum);
      62                 :          0 :                 if (uh->check == 0)
      63                 :          0 :                         uh->check = CSUM_MANGLED_0;
      64                 :            : 
      65                 :          0 :                 skb->ip_summed = CHECKSUM_UNNECESSARY;
      66                 :            : 
      67                 :            :                 /* If there is no outer header we can fake a checksum offload
      68                 :            :                  * due to the fact that we have already done the checksum in
      69                 :            :                  * software prior to segmenting the frame.
      70                 :            :                  */
      71                 :          0 :                 if (!skb->encap_hdr_csum)
      72                 :          0 :                         features |= NETIF_F_HW_CSUM;
      73                 :            : 
      74                 :            :                 /* Check if there is enough headroom to insert fragment header. */
      75                 :            :                 tnl_hlen = skb_tnl_header_len(skb);
      76                 :          0 :                 if (skb->mac_header < (tnl_hlen + frag_hdr_sz)) {
      77                 :          0 :                         if (gso_pskb_expand_head(skb, tnl_hlen + frag_hdr_sz))
      78                 :            :                                 goto out;
      79                 :            :                 }
      80                 :            : 
      81                 :            :                 /* Find the unfragmentable header and shift it left by frag_hdr_sz
      82                 :            :                  * bytes to insert fragment header.
      83                 :            :                  */
      84                 :          0 :                 err = ip6_find_1stfragopt(skb, &prevhdr);
      85                 :          0 :                 if (err < 0)
      86                 :          0 :                         return ERR_PTR(err);
      87                 :          0 :                 unfrag_ip6hlen = err;
      88                 :          0 :                 nexthdr = *prevhdr;
      89                 :          0 :                 *prevhdr = NEXTHDR_FRAGMENT;
      90                 :          0 :                 unfrag_len = (skb_network_header(skb) - skb_mac_header(skb)) +
      91                 :          0 :                              unfrag_ip6hlen + tnl_hlen;
      92                 :          0 :                 packet_start = (u8 *) skb->head + SKB_GSO_CB(skb)->mac_offset;
      93                 :          0 :                 memmove(packet_start-frag_hdr_sz, packet_start, unfrag_len);
      94                 :            : 
      95                 :          0 :                 SKB_GSO_CB(skb)->mac_offset -= frag_hdr_sz;
      96                 :          0 :                 skb->mac_header -= frag_hdr_sz;
      97                 :          0 :                 skb->network_header -= frag_hdr_sz;
      98                 :            : 
      99                 :          0 :                 fptr = (struct frag_hdr *)(skb_network_header(skb) + unfrag_ip6hlen);
     100                 :          0 :                 fptr->nexthdr = nexthdr;
     101                 :          0 :                 fptr->reserved = 0;
     102                 :          0 :                 fptr->identification = ipv6_proxy_select_ident(dev_net(skb->dev), skb);
     103                 :            : 
     104                 :            :                 /* Fragment the skb. ipv6 header and the remaining fields of the
     105                 :            :                  * fragment header are updated in ipv6_gso_segment()
     106                 :            :                  */
     107                 :          0 :                 segs = skb_segment(skb, features);
     108                 :            :         }
     109                 :            : 
     110                 :            : out:
     111                 :          0 :         return segs;
     112                 :            : }
     113                 :            : 
     114                 :            : INDIRECT_CALLABLE_SCOPE
     115                 :          0 : struct sk_buff *udp6_gro_receive(struct list_head *head, struct sk_buff *skb)
     116                 :            : {
     117                 :          0 :         struct udphdr *uh = udp_gro_udphdr(skb);
     118                 :            : 
     119                 :          0 :         if (unlikely(!uh) || !static_branch_unlikely(&udpv6_encap_needed_key))
     120                 :            :                 goto flush;
     121                 :            : 
     122                 :            :         /* Don't bother verifying checksum if we're going to flush anyway. */
     123                 :          0 :         if (NAPI_GRO_CB(skb)->flush)
     124                 :            :                 goto skip;
     125                 :            : 
     126                 :          0 :         if (skb_gro_checksum_validate_zero_check(skb, IPPROTO_UDP, uh->check,
     127                 :            :                                                  ip6_gro_compute_pseudo))
     128                 :            :                 goto flush;
     129                 :          0 :         else if (uh->check)
     130                 :          0 :                 skb_gro_checksum_try_convert(skb, IPPROTO_UDP, uh->check,
     131                 :            :                                              ip6_gro_compute_pseudo);
     132                 :            : 
     133                 :            : skip:
     134                 :          0 :         NAPI_GRO_CB(skb)->is_ipv6 = 1;
     135                 :          0 :         return udp_gro_receive(head, skb, uh, udp6_lib_lookup_skb);
     136                 :            : 
     137                 :            : flush:
     138                 :          0 :         NAPI_GRO_CB(skb)->flush = 1;
     139                 :          0 :         return NULL;
     140                 :            : }
     141                 :            : 
     142                 :          0 : INDIRECT_CALLABLE_SCOPE int udp6_gro_complete(struct sk_buff *skb, int nhoff)
     143                 :            : {
     144                 :            :         const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
     145                 :          0 :         struct udphdr *uh = (struct udphdr *)(skb->data + nhoff);
     146                 :            : 
     147                 :          0 :         if (uh->check)
     148                 :          0 :                 uh->check = ~udp_v6_check(skb->len - nhoff, &ipv6h->saddr,
     149                 :            :                                           &ipv6h->daddr, 0);
     150                 :            : 
     151                 :          0 :         return udp_gro_complete(skb, nhoff, udp6_lib_lookup_skb);
     152                 :            : }
     153                 :            : 
     154                 :            : static const struct net_offload udpv6_offload = {
     155                 :            :         .callbacks = {
     156                 :            :                 .gso_segment    =       udp6_ufo_fragment,
     157                 :            :                 .gro_receive    =       udp6_gro_receive,
     158                 :            :                 .gro_complete   =       udp6_gro_complete,
     159                 :            :         },
     160                 :            : };
     161                 :            : 
     162                 :          3 : int udpv6_offload_init(void)
     163                 :            : {
     164                 :          3 :         return inet6_add_offload(&udpv6_offload, IPPROTO_UDP);
     165                 :            : }
     166                 :            : 
     167                 :          0 : int udpv6_offload_exit(void)
     168                 :            : {
     169                 :          0 :         return inet6_del_offload(&udpv6_offload, IPPROTO_UDP);
     170                 :            : }