xref: /openbmc/linux/net/ipv6/udp_offload.c (revision b4e18b29)
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 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 	if (skb->encapsulation && skb_shinfo(skb)->gso_type &
32 	    (SKB_GSO_UDP_TUNNEL|SKB_GSO_UDP_TUNNEL_CSUM))
33 		segs = skb_udp_tunnel_segment(skb, features, true);
34 	else {
35 		const struct ipv6hdr *ipv6h;
36 		struct udphdr *uh;
37 
38 		if (!(skb_shinfo(skb)->gso_type & (SKB_GSO_UDP | SKB_GSO_UDP_L4)))
39 			goto out;
40 
41 		if (!pskb_may_pull(skb, sizeof(struct udphdr)))
42 			goto out;
43 
44 		if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4)
45 			return __udp_gso_segment(skb, features, true);
46 
47 		mss = skb_shinfo(skb)->gso_size;
48 		if (unlikely(skb->len <= mss))
49 			goto out;
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 		uh->check = 0;
59 		csum = skb_checksum(skb, 0, skb->len, 0);
60 		uh->check = udp_v6_check(skb->len, &ipv6h->saddr,
61 					  &ipv6h->daddr, csum);
62 		if (uh->check == 0)
63 			uh->check = CSUM_MANGLED_0;
64 
65 		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 		if (!skb->encap_hdr_csum)
72 			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 		if (skb->mac_header < (tnl_hlen + frag_hdr_sz)) {
77 			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 		err = ip6_find_1stfragopt(skb, &prevhdr);
85 		if (err < 0)
86 			return ERR_PTR(err);
87 		unfrag_ip6hlen = err;
88 		nexthdr = *prevhdr;
89 		*prevhdr = NEXTHDR_FRAGMENT;
90 		unfrag_len = (skb_network_header(skb) - skb_mac_header(skb)) +
91 			     unfrag_ip6hlen + tnl_hlen;
92 		packet_start = (u8 *) skb->head + SKB_GSO_CB(skb)->mac_offset;
93 		memmove(packet_start-frag_hdr_sz, packet_start, unfrag_len);
94 
95 		SKB_GSO_CB(skb)->mac_offset -= frag_hdr_sz;
96 		skb->mac_header -= frag_hdr_sz;
97 		skb->network_header -= frag_hdr_sz;
98 
99 		fptr = (struct frag_hdr *)(skb_network_header(skb) + unfrag_ip6hlen);
100 		fptr->nexthdr = nexthdr;
101 		fptr->reserved = 0;
102 		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 		segs = skb_segment(skb, features);
108 	}
109 
110 out:
111 	return segs;
112 }
113 
114 static struct sock *udp6_gro_lookup_skb(struct sk_buff *skb, __be16 sport,
115 					__be16 dport)
116 {
117 	const struct ipv6hdr *iph = skb_gro_network_header(skb);
118 
119 	return __udp6_lib_lookup(dev_net(skb->dev), &iph->saddr, sport,
120 				 &iph->daddr, dport, inet6_iif(skb),
121 				 inet6_sdif(skb), &udp_table, NULL);
122 }
123 
124 INDIRECT_CALLABLE_SCOPE
125 struct sk_buff *udp6_gro_receive(struct list_head *head, struct sk_buff *skb)
126 {
127 	struct udphdr *uh = udp_gro_udphdr(skb);
128 	struct sock *sk = NULL;
129 	struct sk_buff *pp;
130 
131 	if (unlikely(!uh))
132 		goto flush;
133 
134 	/* Don't bother verifying checksum if we're going to flush anyway. */
135 	if (NAPI_GRO_CB(skb)->flush)
136 		goto skip;
137 
138 	if (skb_gro_checksum_validate_zero_check(skb, IPPROTO_UDP, uh->check,
139 						 ip6_gro_compute_pseudo))
140 		goto flush;
141 	else if (uh->check)
142 		skb_gro_checksum_try_convert(skb, IPPROTO_UDP,
143 					     ip6_gro_compute_pseudo);
144 
145 skip:
146 	NAPI_GRO_CB(skb)->is_ipv6 = 1;
147 	rcu_read_lock();
148 
149 	if (static_branch_unlikely(&udpv6_encap_needed_key))
150 		sk = udp6_gro_lookup_skb(skb, uh->source, uh->dest);
151 
152 	pp = udp_gro_receive(head, skb, uh, sk);
153 	rcu_read_unlock();
154 	return pp;
155 
156 flush:
157 	NAPI_GRO_CB(skb)->flush = 1;
158 	return NULL;
159 }
160 
161 INDIRECT_CALLABLE_SCOPE int udp6_gro_complete(struct sk_buff *skb, int nhoff)
162 {
163 	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
164 	struct udphdr *uh = (struct udphdr *)(skb->data + nhoff);
165 
166 	if (NAPI_GRO_CB(skb)->is_flist) {
167 		uh->len = htons(skb->len - nhoff);
168 
169 		skb_shinfo(skb)->gso_type |= (SKB_GSO_FRAGLIST|SKB_GSO_UDP_L4);
170 		skb_shinfo(skb)->gso_segs = NAPI_GRO_CB(skb)->count;
171 
172 		if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
173 			if (skb->csum_level < SKB_MAX_CSUM_LEVEL)
174 				skb->csum_level++;
175 		} else {
176 			skb->ip_summed = CHECKSUM_UNNECESSARY;
177 			skb->csum_level = 0;
178 		}
179 
180 		return 0;
181 	}
182 
183 	if (uh->check)
184 		uh->check = ~udp_v6_check(skb->len - nhoff, &ipv6h->saddr,
185 					  &ipv6h->daddr, 0);
186 
187 	return udp_gro_complete(skb, nhoff, udp6_lib_lookup_skb);
188 }
189 
190 static const struct net_offload udpv6_offload = {
191 	.callbacks = {
192 		.gso_segment	=	udp6_ufo_fragment,
193 		.gro_receive	=	udp6_gro_receive,
194 		.gro_complete	=	udp6_gro_complete,
195 	},
196 };
197 
198 int udpv6_offload_init(void)
199 {
200 	return inet6_add_offload(&udpv6_offload, IPPROTO_UDP);
201 }
202 
203 int udpv6_offload_exit(void)
204 {
205 	return inet6_del_offload(&udpv6_offload, IPPROTO_UDP);
206 }
207