[linux-block.git] / include / linux / virtio_net.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_VIRTIO_NET_H
#define _LINUX_VIRTIO_NET_H

#include <linux/if_vlan.h>
#include <uapi/linux/tcp.h>
#include <uapi/linux/udp.h>
#include <uapi/linux/virtio_net.h>

static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
					   const struct virtio_net_hdr *hdr)
{
	switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
	case VIRTIO_NET_HDR_GSO_TCPV4:
	case VIRTIO_NET_HDR_GSO_UDP:
		skb->protocol = cpu_to_be16(ETH_P_IP);
		break;
	case VIRTIO_NET_HDR_GSO_TCPV6:
		skb->protocol = cpu_to_be16(ETH_P_IPV6);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static inline int virtio_net_hdr_to_skb(struct sk_buff *skb,
					const struct virtio_net_hdr *hdr,
					bool little_endian)
{
	unsigned int gso_type = 0;
	unsigned int thlen = 0;
	unsigned int p_off = 0;
	unsigned int ip_proto;

	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
		switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
		case VIRTIO_NET_HDR_GSO_TCPV4:
			gso_type = SKB_GSO_TCPV4;
			ip_proto = IPPROTO_TCP;
			thlen = sizeof(struct tcphdr);
			break;
		case VIRTIO_NET_HDR_GSO_TCPV6:
			gso_type = SKB_GSO_TCPV6;
			ip_proto = IPPROTO_TCP;
			thlen = sizeof(struct tcphdr);
			break;
		case VIRTIO_NET_HDR_GSO_UDP:
			gso_type = SKB_GSO_UDP;
			ip_proto = IPPROTO_UDP;
			thlen = sizeof(struct udphdr);
			break;
		default:
			return -EINVAL;
		}

		if (hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
			gso_type |= SKB_GSO_TCP_ECN;

		if (hdr->gso_size == 0)
			return -EINVAL;
	}

	if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
		u16 start = __virtio16_to_cpu(little_endian, hdr->csum_start);
		u16 off = __virtio16_to_cpu(little_endian, hdr->csum_offset);

		if (!skb_partial_csum_set(skb, start, off))
			return -EINVAL;

		p_off = skb_transport_offset(skb) + thlen;
		if (p_off > skb_headlen(skb))
			return -EINVAL;
	} else {
		/* gso packets without NEEDS_CSUM do not set transport_offset.
		 * probe and drop if does not match one of the above types.
		 */
		if (gso_type && skb->network_header) {
			struct flow_keys_basic keys;

			if (!skb->protocol)
				virtio_net_hdr_set_proto(skb, hdr);
retry:
			if (!skb_flow_dissect_flow_keys_basic(NULL, skb, &keys,
							      NULL, 0, 0, 0,
							      0)) {
				/* UFO does not specify ipv4 or 6: try both */
				if (gso_type & SKB_GSO_UDP &&
				    skb->protocol == htons(ETH_P_IP)) {
					skb->protocol = htons(ETH_P_IPV6);
					goto retry;
				}
				return -EINVAL;
			}

			p_off = keys.control.thoff + thlen;
			if (p_off > skb_headlen(skb) ||
			    keys.basic.ip_proto != ip_proto)
				return -EINVAL;

			skb_set_transport_header(skb, keys.control.thoff);
		} else if (gso_type) {
			p_off = thlen;
			if (p_off > skb_headlen(skb))
				return -EINVAL;
		}
	}

	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
		u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);

		if (skb->len - p_off <= gso_size)
			return -EINVAL;

		skb_shinfo(skb)->gso_size = gso_size;
		skb_shinfo(skb)->gso_type = gso_type;

		/* Header must be checked, and gso_segs computed. */
		skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
		skb_shinfo(skb)->gso_segs = 0;
	}

	return 0;
}

static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
					  struct virtio_net_hdr *hdr,
					  bool little_endian,
					  bool has_data_valid,
					  int vlan_hlen)
{
	memset(hdr, 0, sizeof(*hdr));   /* no info leak */

	if (skb_is_gso(skb)) {
		struct skb_shared_info *sinfo = skb_shinfo(skb);

		/* This is a hint as to how much should be linear. */
		hdr->hdr_len = __cpu_to_virtio16(little_endian,
						 skb_headlen(skb));
		hdr->gso_size = __cpu_to_virtio16(little_endian,
						  sinfo->gso_size);
		if (sinfo->gso_type & SKB_GSO_TCPV4)
			hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
		else if (sinfo->gso_type & SKB_GSO_TCPV6)
			hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
		else
			return -EINVAL;
		if (sinfo->gso_type & SKB_GSO_TCP_ECN)
			hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
	} else
		hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
		hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
		hdr->csum_start = __cpu_to_virtio16(little_endian,
			skb_checksum_start_offset(skb) + vlan_hlen);
		hdr->csum_offset = __cpu_to_virtio16(little_endian,
				skb->csum_offset);
	} else if (has_data_valid &&
		   skb->ip_summed == CHECKSUM_UNNECESSARY) {
		hdr->flags = VIRTIO_NET_HDR_F_DATA_VALID;
	} /* else everything is zero */

	return 0;
}

#endif /* _LINUX_VIRTIO_NET_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
fd2a0437 MR	2	#ifndef _LINUX_VIRTIO_NET_H
	3	#define _LINUX_VIRTIO_NET_H
	4
	5	#include <linux/if_vlan.h>
9274124f WB	6	#include <uapi/linux/tcp.h>
9274124f WB	7	#include <uapi/linux/udp.h>
fd2a0437 MR	8	#include <uapi/linux/virtio_net.h>
fd2a0437 MR	9
9d2f67e4 JT	10	static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
	11	const struct virtio_net_hdr *hdr)
	12	{
	13	switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
	14	case VIRTIO_NET_HDR_GSO_TCPV4:
	15	case VIRTIO_NET_HDR_GSO_UDP:
	16	skb->protocol = cpu_to_be16(ETH_P_IP);
	17	break;
	18	case VIRTIO_NET_HDR_GSO_TCPV6:
	19	skb->protocol = cpu_to_be16(ETH_P_IPV6);
	20	break;
	21	default:
	22	return -EINVAL;
	23	}
	24
	25	return 0;
	26	}
	27
fd2a0437 MR	28	static inline int virtio_net_hdr_to_skb(struct sk_buff *skb,
	29	const struct virtio_net_hdr *hdr,
	30	bool little_endian)
	31	{
0c19f846	32	unsigned int gso_type = 0;
9274124f	33	unsigned int thlen = 0;
6dd912f8	34	unsigned int p_off = 0;
9274124f	35	unsigned int ip_proto;
fd2a0437 MR	36
	37	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
	38	switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
	39	case VIRTIO_NET_HDR_GSO_TCPV4:
	40	gso_type = SKB_GSO_TCPV4;
9274124f WB	41	ip_proto = IPPROTO_TCP;
9274124f WB	42	thlen = sizeof(struct tcphdr);
fd2a0437 MR	43	break;
	44	case VIRTIO_NET_HDR_GSO_TCPV6:
	45	gso_type = SKB_GSO_TCPV6;
9274124f WB	46	ip_proto = IPPROTO_TCP;
9274124f WB	47	thlen = sizeof(struct tcphdr);
fd2a0437	48	break;
0c19f846 WB	49	case VIRTIO_NET_HDR_GSO_UDP:
0c19f846 WB	50	gso_type = SKB_GSO_UDP;
9274124f WB	51	ip_proto = IPPROTO_UDP;
9274124f WB	52	thlen = sizeof(struct udphdr);
0c19f846	53	break;
fd2a0437 MR	54	default:
	55	return -EINVAL;
	56	}
	57
	58	if (hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
	59	gso_type \|= SKB_GSO_TCP_ECN;
	60
	61	if (hdr->gso_size == 0)
	62	return -EINVAL;
	63	}
	64
	65	if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
	66	u16 start = __virtio16_to_cpu(little_endian, hdr->csum_start);
	67	u16 off = __virtio16_to_cpu(little_endian, hdr->csum_offset);
	68
	69	if (!skb_partial_csum_set(skb, start, off))
	70	return -EINVAL;
9274124f	71
6dd912f8 WB	72	p_off = skb_transport_offset(skb) + thlen;
6dd912f8 WB	73	if (p_off > skb_headlen(skb))
9274124f	74	return -EINVAL;
d5be7f63 WB	75	} else {
	76	/* gso packets without NEEDS_CSUM do not set transport_offset.
	77	* probe and drop if does not match one of the above types.
	78	*/
9e8db591	79	if (gso_type && skb->network_header) {
9274124f WB	80	struct flow_keys_basic keys;
9274124f WB	81
9e8db591 WB	82	if (!skb->protocol)
	83	virtio_net_hdr_set_proto(skb, hdr);
	84	retry:
9274124f WB	85	if (!skb_flow_dissect_flow_keys_basic(NULL, skb, &keys,
	86	NULL, 0, 0, 0,
	87	0)) {
9e8db591 WB	88	/* UFO does not specify ipv4 or 6: try both */
	89	if (gso_type & SKB_GSO_UDP &&
	90	skb->protocol == htons(ETH_P_IP)) {
	91	skb->protocol = htons(ETH_P_IPV6);
	92	goto retry;
	93	}
d5be7f63	94	return -EINVAL;
9e8db591	95	}
9274124f	96
6dd912f8 WB	97	p_off = keys.control.thoff + thlen;
6dd912f8 WB	98	if (p_off > skb_headlen(skb) \|\|
9274124f WB	99	keys.basic.ip_proto != ip_proto)
	100	return -EINVAL;
	101
	102	skb_set_transport_header(skb, keys.control.thoff);
6dd912f8 WB	103	} else if (gso_type) {
	104	p_off = thlen;
	105	if (p_off > skb_headlen(skb))
	106	return -EINVAL;
d5be7f63	107	}
fd2a0437 MR	108	}
	109
	110	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
	111	u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);
	112
6dd912f8 WB	113	if (skb->len - p_off <= gso_size)
	114	return -EINVAL;
	115
fd2a0437 MR	116	skb_shinfo(skb)->gso_size = gso_size;
	117	skb_shinfo(skb)->gso_type = gso_type;
	118
	119	/* Header must be checked, and gso_segs computed. */
	120	skb_shinfo(skb)->gso_type \|= SKB_GSO_DODGY;
	121	skb_shinfo(skb)->gso_segs = 0;
	122	}
	123
	124	return 0;
	125	}
	126
	127	static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
	128	struct virtio_net_hdr *hdr,
6391a448	129	bool little_endian,
fd3a8862 WB	130	bool has_data_valid,
fd3a8862 WB	131	int vlan_hlen)
fd2a0437	132	{
9403cd7c	133	memset(hdr, 0, sizeof(hdr)); / no info leak */
fd2a0437 MR	134
	135	if (skb_is_gso(skb)) {
	136	struct skb_shared_info *sinfo = skb_shinfo(skb);
	137
	138	/* This is a hint as to how much should be linear. */
	139	hdr->hdr_len = __cpu_to_virtio16(little_endian,
	140	skb_headlen(skb));
	141	hdr->gso_size = __cpu_to_virtio16(little_endian,
	142	sinfo->gso_size);
	143	if (sinfo->gso_type & SKB_GSO_TCPV4)
	144	hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
	145	else if (sinfo->gso_type & SKB_GSO_TCPV6)
	146	hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
fd2a0437 MR	147	else
	148	return -EINVAL;
	149	if (sinfo->gso_type & SKB_GSO_TCP_ECN)
	150	hdr->gso_type \|= VIRTIO_NET_HDR_GSO_ECN;
	151	} else
	152	hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
	153
	154	if (skb->ip_summed == CHECKSUM_PARTIAL) {
	155	hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
fd3a8862 WB	156	hdr->csum_start = __cpu_to_virtio16(little_endian,
fd3a8862 WB	157	skb_checksum_start_offset(skb) + vlan_hlen);
fd2a0437 MR	158	hdr->csum_offset = __cpu_to_virtio16(little_endian,
fd2a0437 MR	159	skb->csum_offset);
6391a448 JW	160	} else if (has_data_valid &&
	161	skb->ip_summed == CHECKSUM_UNNECESSARY) {
	162	hdr->flags = VIRTIO_NET_HDR_F_DATA_VALID;
fd2a0437 MR	163	} /* else everything is zero */
	164
	165	return 0;
	166	}
	167
d66016a7	168	#endif /* _LINUX_VIRTIO_NET_H */