virtio_net.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _LINUX_VIRTIO_NET_H
  3#define _LINUX_VIRTIO_NET_H
  4
  5#include <linux/if_vlan.h>
  6#include <linux/ip.h>
  7#include <linux/ipv6.h>
  8#include <linux/udp.h>
  9#include <uapi/linux/tcp.h>
 10#include <uapi/linux/virtio_net.h>
 11
 12static inline bool virtio_net_hdr_match_proto(__be16 protocol, __u8 gso_type)
 13{
 14	switch (gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 15	case VIRTIO_NET_HDR_GSO_TCPV4:
 16		return protocol == cpu_to_be16(ETH_P_IP);
 17	case VIRTIO_NET_HDR_GSO_TCPV6:
 18		return protocol == cpu_to_be16(ETH_P_IPV6);
 19	case VIRTIO_NET_HDR_GSO_UDP:
 20	case VIRTIO_NET_HDR_GSO_UDP_L4:
 21		return protocol == cpu_to_be16(ETH_P_IP) ||
 22		       protocol == cpu_to_be16(ETH_P_IPV6);
 23	default:
 24		return false;
 25	}
 26}
 27
 28static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
 29					   const struct virtio_net_hdr *hdr)
 30{
 31	if (skb->protocol)
 32		return 0;
 33
 34	switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 35	case VIRTIO_NET_HDR_GSO_TCPV4:
 36	case VIRTIO_NET_HDR_GSO_UDP:
 37	case VIRTIO_NET_HDR_GSO_UDP_L4:
 38		skb->protocol = cpu_to_be16(ETH_P_IP);
 39		break;
 40	case VIRTIO_NET_HDR_GSO_TCPV6:
 41		skb->protocol = cpu_to_be16(ETH_P_IPV6);
 42		break;
 43	default:
 44		return -EINVAL;
 45	}
 46
 47	return 0;
 48}
 49
 50static inline int __virtio_net_hdr_to_skb(struct sk_buff *skb,
 51					  const struct virtio_net_hdr *hdr,
 52					  bool little_endian, u8 hdr_gso_type)
 53{
 54	unsigned int nh_min_len = sizeof(struct iphdr);
 55	unsigned int gso_type = 0;
 56	unsigned int thlen = 0;
 57	unsigned int p_off = 0;
 58	unsigned int ip_proto;
 59
 60	if (hdr_gso_type != VIRTIO_NET_HDR_GSO_NONE) {
 61		switch (hdr_gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 62		case VIRTIO_NET_HDR_GSO_TCPV4:
 63			gso_type = SKB_GSO_TCPV4;
 64			ip_proto = IPPROTO_TCP;
 65			thlen = sizeof(struct tcphdr);
 66			break;
 67		case VIRTIO_NET_HDR_GSO_TCPV6:
 68			gso_type = SKB_GSO_TCPV6;
 69			ip_proto = IPPROTO_TCP;
 70			thlen = sizeof(struct tcphdr);
 71			nh_min_len = sizeof(struct ipv6hdr);
 72			break;
 73		case VIRTIO_NET_HDR_GSO_UDP:
 74			gso_type = SKB_GSO_UDP;
 75			ip_proto = IPPROTO_UDP;
 76			thlen = sizeof(struct udphdr);
 77			break;
 78		case VIRTIO_NET_HDR_GSO_UDP_L4:
 79			gso_type = SKB_GSO_UDP_L4;
 80			ip_proto = IPPROTO_UDP;
 81			thlen = sizeof(struct udphdr);
 82			break;
 83		default:
 84			return -EINVAL;
 85		}
 86
 87		if (hdr_gso_type & VIRTIO_NET_HDR_GSO_ECN)
 88			gso_type |= SKB_GSO_TCP_ECN;
 89
 90		if (hdr->gso_size == 0)
 91			return -EINVAL;
 92	}
 93
 94	skb_reset_mac_header(skb);
 95
 96	if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
 97		u32 start = __virtio16_to_cpu(little_endian, hdr->csum_start);
 98		u32 off = __virtio16_to_cpu(little_endian, hdr->csum_offset);
 99		u32 needed = start + max_t(u32, thlen, off + sizeof(__sum16));
100
101		if (!pskb_may_pull(skb, needed))
102			return -EINVAL;
103
104		if (!skb_partial_csum_set(skb, start, off))
105			return -EINVAL;
106		if (skb_transport_offset(skb) < nh_min_len)
107			return -EINVAL;
108
109		nh_min_len = skb_transport_offset(skb);
110		p_off = nh_min_len + thlen;
111		if (!pskb_may_pull(skb, p_off))
112			return -EINVAL;
113	} else {
114		/* gso packets without NEEDS_CSUM do not set transport_offset.
115		 * probe and drop if does not match one of the above types.
116		 */
117		if (gso_type && skb->network_header) {
118			struct flow_keys_basic keys;
119
120			if (!skb->protocol) {
121				__be16 protocol = dev_parse_header_protocol(skb);
122
123				if (!protocol)
124					virtio_net_hdr_set_proto(skb, hdr);
125				else if (!virtio_net_hdr_match_proto(protocol,
126								 hdr_gso_type))
127					return -EINVAL;
128				else
129					skb->protocol = protocol;
130			}
131retry:
132			if (!skb_flow_dissect_flow_keys_basic(NULL, skb, &keys,
133							      NULL, 0, 0, 0,
134							      0)) {
135				/* UFO does not specify ipv4 or 6: try both */
136				if (gso_type & SKB_GSO_UDP &&
137				    skb->protocol == htons(ETH_P_IP)) {
138					skb->protocol = htons(ETH_P_IPV6);
139					goto retry;
140				}
141				return -EINVAL;
142			}
143
144			p_off = keys.control.thoff + thlen;
145			if (!pskb_may_pull(skb, p_off) ||
146			    keys.basic.ip_proto != ip_proto)
147				return -EINVAL;
148
149			skb_set_transport_header(skb, keys.control.thoff);
150		} else if (gso_type) {
151			p_off = nh_min_len + thlen;
152			if (!pskb_may_pull(skb, p_off))
153				return -EINVAL;
154		}
155	}
156
157	if (hdr_gso_type != VIRTIO_NET_HDR_GSO_NONE) {
158		u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);
159		unsigned int nh_off = p_off;
160		struct skb_shared_info *shinfo = skb_shinfo(skb);
161
162		switch (gso_type & ~SKB_GSO_TCP_ECN) {
163		case SKB_GSO_UDP:
164			/* UFO may not include transport header in gso_size. */
165			nh_off -= thlen;
166			break;
167		case SKB_GSO_UDP_L4:
168			if (!(hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM))
169				return -EINVAL;
170			if (skb->csum_offset != offsetof(struct udphdr, check))
171				return -EINVAL;
172			if (skb->len - p_off > gso_size * UDP_MAX_SEGMENTS)
173				return -EINVAL;
174			if (gso_type != SKB_GSO_UDP_L4)
175				return -EINVAL;
176			break;
177		case SKB_GSO_TCPV4:
178		case SKB_GSO_TCPV6:
179			if (skb->ip_summed == CHECKSUM_PARTIAL &&
180			    skb->csum_offset != offsetof(struct tcphdr, check))
181				return -EINVAL;
182			break;
183		}
184
185		/* Kernel has a special handling for GSO_BY_FRAGS. */
186		if (gso_size == GSO_BY_FRAGS)
187			return -EINVAL;
188
189		/* Too small packets are not really GSO ones. */
190		if (skb->len - nh_off > gso_size) {
191			shinfo->gso_size = gso_size;
192			shinfo->gso_type = gso_type;
193
194			/* Header must be checked, and gso_segs computed. */
195			shinfo->gso_type |= SKB_GSO_DODGY;
196			shinfo->gso_segs = 0;
197		}
198	}
199
200	return 0;
201}
202
203static inline int virtio_net_hdr_to_skb(struct sk_buff *skb,
204					const struct virtio_net_hdr *hdr,
205					bool little_endian)
206{
207	return __virtio_net_hdr_to_skb(skb, hdr, little_endian, hdr->gso_type);
208}
209
210/* This function must be called after virtio_net_hdr_from_skb(). */
211static inline void __virtio_net_set_hdrlen(const struct sk_buff *skb,
212					   struct virtio_net_hdr *hdr,
213					   bool little_endian)
214{
215	u16 hdr_len;
216
217	hdr_len = skb_transport_offset(skb);
218
219	if (hdr->gso_type == VIRTIO_NET_HDR_GSO_UDP_L4)
220		hdr_len += sizeof(struct udphdr);
221	else
222		hdr_len += tcp_hdrlen(skb);
223
224	hdr->hdr_len = __cpu_to_virtio16(little_endian, hdr_len);
225}
226
227/* This function must be called after virtio_net_hdr_from_skb(). */
228static inline void __virtio_net_set_tnl_hdrlen(const struct sk_buff *skb,
229					       struct virtio_net_hdr *hdr)
230{
231	u16 hdr_len;
232
233	hdr_len = skb_inner_transport_offset(skb);
234
235	if (hdr->gso_type == VIRTIO_NET_HDR_GSO_UDP_L4)
236		hdr_len += sizeof(struct udphdr);
237	else
238		hdr_len += inner_tcp_hdrlen(skb);
239
240	hdr->hdr_len = __cpu_to_virtio16(true, hdr_len);
241}
242
243static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
244					  struct virtio_net_hdr *hdr,
245					  bool little_endian,
246					  bool has_data_valid,
247					  int vlan_hlen)
248{
249	memset(hdr, 0, sizeof(*hdr));   /* no info leak */
250
251	if (skb_is_gso(skb)) {
252		struct skb_shared_info *sinfo = skb_shinfo(skb);
253
254		/* This is a hint as to how much should be linear. */
255		hdr->hdr_len = __cpu_to_virtio16(little_endian,
256						 skb_headlen(skb));
257		hdr->gso_size = __cpu_to_virtio16(little_endian,
258						  sinfo->gso_size);
259		if (sinfo->gso_type & SKB_GSO_TCPV4)
260			hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
261		else if (sinfo->gso_type & SKB_GSO_TCPV6)
262			hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
263		else if (sinfo->gso_type & SKB_GSO_UDP_L4)
264			hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP_L4;
265		else
266			return -EINVAL;
267		if (sinfo->gso_type & SKB_GSO_TCP_ECN)
268			hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
269	} else
270		hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
271
272	if (skb->ip_summed == CHECKSUM_PARTIAL) {
273		hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
274		hdr->csum_start = __cpu_to_virtio16(little_endian,
275			skb_checksum_start_offset(skb) + vlan_hlen);
276		hdr->csum_offset = __cpu_to_virtio16(little_endian,
277				skb->csum_offset);
278	} else if (has_data_valid &&
279		   skb->ip_summed == CHECKSUM_UNNECESSARY) {
280		hdr->flags = VIRTIO_NET_HDR_F_DATA_VALID;
281	} /* else everything is zero */
282
283	return 0;
284}
285
286static inline unsigned int virtio_l3min(bool is_ipv6)
287{
288	return is_ipv6 ? sizeof(struct ipv6hdr) : sizeof(struct iphdr);
289}
290
291static inline int
292virtio_net_hdr_tnl_to_skb(struct sk_buff *skb,
293			  const struct virtio_net_hdr_v1_hash_tunnel *vhdr,
294			  bool tnl_hdr_negotiated,
295			  bool tnl_csum_negotiated,
296			  bool little_endian)
297{
298	const struct virtio_net_hdr *hdr = (const struct virtio_net_hdr *)vhdr;
299	unsigned int inner_nh, outer_th, inner_th;
300	unsigned int inner_l3min, outer_l3min;
301	u8 gso_inner_type, gso_tunnel_type;
302	bool outer_isv6, inner_isv6;
303	int ret;
304
305	gso_tunnel_type = hdr->gso_type & VIRTIO_NET_HDR_GSO_UDP_TUNNEL;
306	if (!gso_tunnel_type)
307		return virtio_net_hdr_to_skb(skb, hdr, little_endian);
308
309	/* Tunnel not supported/negotiated, but the hdr asks for it. */
310	if (!tnl_hdr_negotiated)
311		return -EINVAL;
312
313	/* Either ipv4 or ipv6. */
314	if (gso_tunnel_type == VIRTIO_NET_HDR_GSO_UDP_TUNNEL)
315		return -EINVAL;
316
317	/* The UDP tunnel must carry a GSO packet, but no UFO. */
318	gso_inner_type = hdr->gso_type & ~(VIRTIO_NET_HDR_GSO_ECN |
319					   VIRTIO_NET_HDR_GSO_UDP_TUNNEL);
320	if (!gso_inner_type || gso_inner_type == VIRTIO_NET_HDR_GSO_UDP)
321		return -EINVAL;
322
323	/* Rely on csum being present. */
324	if (!(hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM))
325		return -EINVAL;
326
327	/* Validate offsets. */
328	outer_isv6 = gso_tunnel_type & VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6;
329	inner_isv6 = gso_inner_type == VIRTIO_NET_HDR_GSO_TCPV6;
330	inner_l3min = virtio_l3min(inner_isv6);
331	outer_l3min = ETH_HLEN + virtio_l3min(outer_isv6);
332
333	inner_th = __virtio16_to_cpu(little_endian, hdr->csum_start);
334	inner_nh = le16_to_cpu(vhdr->inner_nh_offset);
335	outer_th = le16_to_cpu(vhdr->outer_th_offset);
336	if (outer_th < outer_l3min ||
337	    inner_nh < outer_th + sizeof(struct udphdr) ||
338	    inner_th < inner_nh + inner_l3min)
339		return -EINVAL;
340
341	/* Let the basic parsing deal with plain GSO features. */
342	ret = __virtio_net_hdr_to_skb(skb, hdr, true,
343				      hdr->gso_type & ~gso_tunnel_type);
344	if (ret)
345		return ret;
346
347	/* In case of USO, the inner protocol is still unknown and
348	 * `inner_isv6` is just a guess, additional parsing is needed.
349	 * The previous validation ensures that accessing an ipv4 inner
350	 * network header is safe.
351	 */
352	if (gso_inner_type == VIRTIO_NET_HDR_GSO_UDP_L4) {
353		struct iphdr *iphdr = (struct iphdr *)(skb->data + inner_nh);
354
355		inner_isv6 = iphdr->version == 6;
356		inner_l3min = virtio_l3min(inner_isv6);
357		if (inner_th < inner_nh + inner_l3min)
358			return -EINVAL;
359	}
360
361	skb_set_inner_protocol(skb, inner_isv6 ? htons(ETH_P_IPV6) :
362						 htons(ETH_P_IP));
363	if (hdr->flags & VIRTIO_NET_HDR_F_UDP_TUNNEL_CSUM) {
364		if (!tnl_csum_negotiated)
365			return -EINVAL;
366
367		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
368	} else {
369		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
370	}
371
372	skb->inner_transport_header = inner_th + skb_headroom(skb);
373	skb->inner_network_header = inner_nh + skb_headroom(skb);
374	skb->inner_mac_header = inner_nh + skb_headroom(skb);
375	skb->transport_header = outer_th + skb_headroom(skb);
376	skb->encapsulation = 1;
377	return 0;
378}
379
380/* Checksum-related fields validation for the driver */
381static inline int virtio_net_handle_csum_offload(struct sk_buff *skb,
382						 struct virtio_net_hdr *hdr,
383						 bool tnl_csum_negotiated)
384{
385	if (!(hdr->gso_type & VIRTIO_NET_HDR_GSO_UDP_TUNNEL)) {
386		if (!(hdr->flags & VIRTIO_NET_HDR_F_DATA_VALID))
387			return 0;
388
389		skb->ip_summed = CHECKSUM_UNNECESSARY;
390		if (!(hdr->flags & VIRTIO_NET_HDR_F_UDP_TUNNEL_CSUM))
391			return 0;
392
393		/* tunnel csum packets are invalid when the related
394		 * feature has not been negotiated
395		 */
396		if (!tnl_csum_negotiated)
397			return -EINVAL;
398		skb->csum_level = 1;
399		return 0;
400	}
401
402	/* DATA_VALID is mutually exclusive with NEEDS_CSUM, and GSO
403	 * over UDP tunnel requires the latter
404	 */
405	if (hdr->flags & VIRTIO_NET_HDR_F_DATA_VALID)
406		return -EINVAL;
407	return 0;
408}
409
410/*
411 * vlan_hlen always refers to the outermost MAC header. That also
412 * means it refers to the only MAC header, if the packet does not carry
413 * any encapsulation.
414 */
415static inline int
416virtio_net_hdr_tnl_from_skb(const struct sk_buff *skb,
417			    struct virtio_net_hdr_v1_hash_tunnel *vhdr,
418			    bool tnl_hdr_negotiated,
419			    bool little_endian,
420			    int vlan_hlen,
421			    bool has_data_valid,
422			    bool feature_hdrlen)
423{
424	struct virtio_net_hdr *hdr = (struct virtio_net_hdr *)vhdr;
425	unsigned int inner_nh, outer_th;
426	int tnl_gso_type;
427	int ret;
428
429	tnl_gso_type = skb_shinfo(skb)->gso_type & (SKB_GSO_UDP_TUNNEL |
430						    SKB_GSO_UDP_TUNNEL_CSUM);
431	if (!tnl_gso_type) {
432		ret = virtio_net_hdr_from_skb(skb, hdr, little_endian,
433					      has_data_valid, vlan_hlen);
434		if (ret)
435			return ret;
436
437		if (feature_hdrlen && hdr->hdr_len)
438			__virtio_net_set_hdrlen(skb, hdr, little_endian);
439
440		return ret;
441	}
442
443	/* Tunnel support not negotiated but skb ask for it. */
444	if (!tnl_hdr_negotiated)
445		return -EINVAL;
446
447	vhdr->hash_hdr.hash_value_lo = 0;
448	vhdr->hash_hdr.hash_value_hi = 0;
449        vhdr->hash_hdr.hash_report = 0;
450        vhdr->hash_hdr.padding = 0;
451
452	/* Let the basic parsing deal with plain GSO features. */
453	skb_shinfo(skb)->gso_type &= ~tnl_gso_type;
454	ret = virtio_net_hdr_from_skb(skb, hdr, true, false, vlan_hlen);
455	skb_shinfo(skb)->gso_type |= tnl_gso_type;
456	if (ret)
457		return ret;
458
459	if (feature_hdrlen && hdr->hdr_len)
460		__virtio_net_set_tnl_hdrlen(skb, hdr);
461
462	if (skb->protocol == htons(ETH_P_IPV6))
463		hdr->gso_type |= VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6;
464	else
465		hdr->gso_type |= VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV4;
466
467	if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_TUNNEL_CSUM)
468		hdr->flags |= VIRTIO_NET_HDR_F_UDP_TUNNEL_CSUM;
469
470	inner_nh = skb->inner_network_header - skb_headroom(skb);
471	outer_th = skb->transport_header - skb_headroom(skb);
472	vhdr->inner_nh_offset = cpu_to_le16(inner_nh);
473	vhdr->outer_th_offset = cpu_to_le16(outer_th);
474	return 0;
475}
476
477#endif /* _LINUX_VIRTIO_NET_H */