1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2017 - Cambridge Greys Limited
4  * Copyright (C) 2011 - 2014 Cisco Systems Inc
5  */
6 
7 #include <linux/etherdevice.h>
8 #include <linux/netdevice.h>
9 #include <linux/skbuff.h>
10 #include <linux/slab.h>
11 #include <asm/byteorder.h>
12 #include <uapi/linux/ip.h>
13 #include <uapi/linux/virtio_net.h>
14 #include <linux/virtio_net.h>
15 #include <linux/virtio_byteorder.h>
16 #include <linux/netdev_features.h>
17 #include "vector_user.h"
18 #include "vector_kern.h"
19 
20 #define GOOD_LINEAR 512
21 #define GSO_ERROR "Incoming GSO frames and GRO disabled on the interface"
22 
23 struct gre_minimal_header {
24 	uint16_t header;
25 	uint16_t arptype;
26 };
27 
28 
29 struct uml_gre_data {
30 	uint32_t rx_key;
31 	uint32_t tx_key;
32 	uint32_t sequence;
33 
34 	bool ipv6;
35 	bool has_sequence;
36 	bool pin_sequence;
37 	bool checksum;
38 	bool key;
39 	struct gre_minimal_header expected_header;
40 
41 	uint32_t checksum_offset;
42 	uint32_t key_offset;
43 	uint32_t sequence_offset;
44 
45 };
46 
47 struct uml_l2tpv3_data {
48 	uint64_t rx_cookie;
49 	uint64_t tx_cookie;
50 	uint64_t rx_session;
51 	uint64_t tx_session;
52 	uint32_t counter;
53 
54 	bool udp;
55 	bool ipv6;
56 	bool has_counter;
57 	bool pin_counter;
58 	bool cookie;
59 	bool cookie_is_64;
60 
61 	uint32_t cookie_offset;
62 	uint32_t session_offset;
63 	uint32_t counter_offset;
64 };
65 
66 static int l2tpv3_form_header(uint8_t *header,
67 	struct sk_buff *skb, struct vector_private *vp)
68 {
69 	struct uml_l2tpv3_data *td = vp->transport_data;
70 	uint32_t *counter;
71 
72 	if (td->udp)
73 		*(uint32_t *) header = cpu_to_be32(L2TPV3_DATA_PACKET);
74 	(*(uint32_t *) (header + td->session_offset)) = td->tx_session;
75 
76 	if (td->cookie) {
77 		if (td->cookie_is_64)
78 			(*(uint64_t *)(header + td->cookie_offset)) =
79 				td->tx_cookie;
80 		else
81 			(*(uint32_t *)(header + td->cookie_offset)) =
82 				td->tx_cookie;
83 	}
84 	if (td->has_counter) {
85 		counter = (uint32_t *)(header + td->counter_offset);
86 		if (td->pin_counter) {
87 			*counter = 0;
88 		} else {
89 			td->counter++;
90 			*counter = cpu_to_be32(td->counter);
91 		}
92 	}
93 	return 0;
94 }
95 
96 static int gre_form_header(uint8_t *header,
97 		struct sk_buff *skb, struct vector_private *vp)
98 {
99 	struct uml_gre_data *td = vp->transport_data;
100 	uint32_t *sequence;
101 	*((uint32_t *) header) = *((uint32_t *) &td->expected_header);
102 	if (td->key)
103 		(*(uint32_t *) (header + td->key_offset)) = td->tx_key;
104 	if (td->has_sequence) {
105 		sequence = (uint32_t *)(header + td->sequence_offset);
106 		if (td->pin_sequence)
107 			*sequence = 0;
108 		else
109 			*sequence = cpu_to_be32(++td->sequence);
110 	}
111 	return 0;
112 }
113 
114 static int raw_form_header(uint8_t *header,
115 		struct sk_buff *skb, struct vector_private *vp)
116 {
117 	struct virtio_net_hdr *vheader = (struct virtio_net_hdr *) header;
118 
119 	virtio_net_hdr_from_skb(
120 		skb,
121 		vheader,
122 		virtio_legacy_is_little_endian(),
123 		false,
124 		0
125 	);
126 
127 	return 0;
128 }
129 
130 static int l2tpv3_verify_header(
131 	uint8_t *header, struct sk_buff *skb, struct vector_private *vp)
132 {
133 	struct uml_l2tpv3_data *td = vp->transport_data;
134 	uint32_t *session;
135 	uint64_t cookie;
136 
137 	if ((!td->udp) && (!td->ipv6))
138 		header += sizeof(struct iphdr) /* fix for ipv4 raw */;
139 
140 	/* we do not do a strict check for "data" packets as per
141 	 * the RFC spec because the pure IP spec does not have
142 	 * that anyway.
143 	 */
144 
145 	if (td->cookie) {
146 		if (td->cookie_is_64)
147 			cookie = *(uint64_t *)(header + td->cookie_offset);
148 		else
149 			cookie = *(uint32_t *)(header + td->cookie_offset);
150 		if (cookie != td->rx_cookie) {
151 			if (net_ratelimit())
152 				netdev_err(vp->dev, "uml_l2tpv3: unknown cookie id");
153 			return -1;
154 		}
155 	}
156 	session = (uint32_t *) (header + td->session_offset);
157 	if (*session != td->rx_session) {
158 		if (net_ratelimit())
159 			netdev_err(vp->dev, "uml_l2tpv3: session mismatch");
160 		return -1;
161 	}
162 	return 0;
163 }
164 
165 static int gre_verify_header(
166 	uint8_t *header, struct sk_buff *skb, struct vector_private *vp)
167 {
168 
169 	uint32_t key;
170 	struct uml_gre_data *td = vp->transport_data;
171 
172 	if (!td->ipv6)
173 		header += sizeof(struct iphdr) /* fix for ipv4 raw */;
174 
175 	if (*((uint32_t *) header) != *((uint32_t *) &td->expected_header)) {
176 		if (net_ratelimit())
177 			netdev_err(vp->dev, "header type disagreement, expecting %0x, got %0x",
178 				*((uint32_t *) &td->expected_header),
179 				*((uint32_t *) header)
180 			);
181 		return -1;
182 	}
183 
184 	if (td->key) {
185 		key = (*(uint32_t *)(header + td->key_offset));
186 		if (key != td->rx_key) {
187 			if (net_ratelimit())
188 				netdev_err(vp->dev, "unknown key id %0x, expecting %0x",
189 						key, td->rx_key);
190 			return -1;
191 		}
192 	}
193 	return 0;
194 }
195 
196 static int raw_verify_header(
197 	uint8_t *header, struct sk_buff *skb, struct vector_private *vp)
198 {
199 	struct virtio_net_hdr *vheader = (struct virtio_net_hdr *) header;
200 
201 	if ((vheader->gso_type != VIRTIO_NET_HDR_GSO_NONE) &&
202 		(vp->req_size != 65536)) {
203 		if (net_ratelimit())
204 			netdev_err(
205 				vp->dev,
206 				GSO_ERROR
207 		);
208 	}
209 	if ((vheader->flags & VIRTIO_NET_HDR_F_DATA_VALID) > 0)
210 		return 1;
211 
212 	virtio_net_hdr_to_skb(skb, vheader, virtio_legacy_is_little_endian());
213 	return 0;
214 }
215 
216 static bool get_uint_param(
217 	struct arglist *def, char *param, unsigned int *result)
218 {
219 	char *arg = uml_vector_fetch_arg(def, param);
220 
221 	if (arg != NULL) {
222 		if (kstrtoint(arg, 0, result) == 0)
223 			return true;
224 	}
225 	return false;
226 }
227 
228 static bool get_ulong_param(
229 	struct arglist *def, char *param, unsigned long *result)
230 {
231 	char *arg = uml_vector_fetch_arg(def, param);
232 
233 	if (arg != NULL) {
234 		if (kstrtoul(arg, 0, result) == 0)
235 			return true;
236 		return true;
237 	}
238 	return false;
239 }
240 
241 static int build_gre_transport_data(struct vector_private *vp)
242 {
243 	struct uml_gre_data *td;
244 	int temp_int;
245 	int temp_rx;
246 	int temp_tx;
247 
248 	vp->transport_data = kmalloc(sizeof(struct uml_gre_data), GFP_KERNEL);
249 	if (vp->transport_data == NULL)
250 		return -ENOMEM;
251 	td = vp->transport_data;
252 	td->sequence = 0;
253 
254 	td->expected_header.arptype = GRE_IRB;
255 	td->expected_header.header = 0;
256 
257 	vp->form_header = &gre_form_header;
258 	vp->verify_header = &gre_verify_header;
259 	vp->header_size = 4;
260 	td->key_offset = 4;
261 	td->sequence_offset = 4;
262 	td->checksum_offset = 4;
263 
264 	td->ipv6 = false;
265 	if (get_uint_param(vp->parsed, "v6", &temp_int)) {
266 		if (temp_int > 0)
267 			td->ipv6 = true;
268 	}
269 	td->key = false;
270 	if (get_uint_param(vp->parsed, "rx_key", &temp_rx)) {
271 		if (get_uint_param(vp->parsed, "tx_key", &temp_tx)) {
272 			td->key = true;
273 			td->expected_header.header |= GRE_MODE_KEY;
274 			td->rx_key = cpu_to_be32(temp_rx);
275 			td->tx_key = cpu_to_be32(temp_tx);
276 			vp->header_size += 4;
277 			td->sequence_offset += 4;
278 		} else {
279 			return -EINVAL;
280 		}
281 	}
282 
283 	td->sequence = false;
284 	if (get_uint_param(vp->parsed, "sequence", &temp_int)) {
285 		if (temp_int > 0) {
286 			vp->header_size += 4;
287 			td->has_sequence = true;
288 			td->expected_header.header |= GRE_MODE_SEQUENCE;
289 			if (get_uint_param(
290 				vp->parsed, "pin_sequence", &temp_int)) {
291 				if (temp_int > 0)
292 					td->pin_sequence = true;
293 			}
294 		}
295 	}
296 	vp->rx_header_size = vp->header_size;
297 	if (!td->ipv6)
298 		vp->rx_header_size += sizeof(struct iphdr);
299 	return 0;
300 }
301 
302 static int build_l2tpv3_transport_data(struct vector_private *vp)
303 {
304 
305 	struct uml_l2tpv3_data *td;
306 	int temp_int, temp_rxs, temp_txs;
307 	unsigned long temp_rx;
308 	unsigned long temp_tx;
309 
310 	vp->transport_data = kmalloc(
311 		sizeof(struct uml_l2tpv3_data), GFP_KERNEL);
312 
313 	if (vp->transport_data == NULL)
314 		return -ENOMEM;
315 
316 	td = vp->transport_data;
317 
318 	vp->form_header = &l2tpv3_form_header;
319 	vp->verify_header = &l2tpv3_verify_header;
320 	td->counter = 0;
321 
322 	vp->header_size = 4;
323 	td->session_offset = 0;
324 	td->cookie_offset = 4;
325 	td->counter_offset = 4;
326 
327 
328 	td->ipv6 = false;
329 	if (get_uint_param(vp->parsed, "v6", &temp_int)) {
330 		if (temp_int > 0)
331 			td->ipv6 = true;
332 	}
333 
334 	if (get_uint_param(vp->parsed, "rx_session", &temp_rxs)) {
335 		if (get_uint_param(vp->parsed, "tx_session", &temp_txs)) {
336 			td->tx_session = cpu_to_be32(temp_txs);
337 			td->rx_session = cpu_to_be32(temp_rxs);
338 		} else {
339 			return -EINVAL;
340 		}
341 	} else {
342 		return -EINVAL;
343 	}
344 
345 	td->cookie_is_64  = false;
346 	if (get_uint_param(vp->parsed, "cookie64", &temp_int)) {
347 		if (temp_int > 0)
348 			td->cookie_is_64  = true;
349 	}
350 	td->cookie = false;
351 	if (get_ulong_param(vp->parsed, "rx_cookie", &temp_rx)) {
352 		if (get_ulong_param(vp->parsed, "tx_cookie", &temp_tx)) {
353 			td->cookie = true;
354 			if (td->cookie_is_64) {
355 				td->rx_cookie = cpu_to_be64(temp_rx);
356 				td->tx_cookie = cpu_to_be64(temp_tx);
357 				vp->header_size += 8;
358 				td->counter_offset += 8;
359 			} else {
360 				td->rx_cookie = cpu_to_be32(temp_rx);
361 				td->tx_cookie = cpu_to_be32(temp_tx);
362 				vp->header_size += 4;
363 				td->counter_offset += 4;
364 			}
365 		} else {
366 			return -EINVAL;
367 		}
368 	}
369 
370 	td->has_counter = false;
371 	if (get_uint_param(vp->parsed, "counter", &temp_int)) {
372 		if (temp_int > 0) {
373 			td->has_counter = true;
374 			vp->header_size += 4;
375 			if (get_uint_param(
376 				vp->parsed, "pin_counter", &temp_int)) {
377 				if (temp_int > 0)
378 					td->pin_counter = true;
379 			}
380 		}
381 	}
382 
383 	if (get_uint_param(vp->parsed, "udp", &temp_int)) {
384 		if (temp_int > 0) {
385 			td->udp = true;
386 			vp->header_size += 4;
387 			td->counter_offset += 4;
388 			td->session_offset += 4;
389 			td->cookie_offset += 4;
390 		}
391 	}
392 
393 	vp->rx_header_size = vp->header_size;
394 	if ((!td->ipv6) && (!td->udp))
395 		vp->rx_header_size += sizeof(struct iphdr);
396 
397 	return 0;
398 }
399 
400 static int build_raw_transport_data(struct vector_private *vp)
401 {
402 	if (uml_raw_enable_vnet_headers(vp->fds->rx_fd)) {
403 		if (!uml_raw_enable_vnet_headers(vp->fds->tx_fd))
404 			return -1;
405 		vp->form_header = &raw_form_header;
406 		vp->verify_header = &raw_verify_header;
407 		vp->header_size = sizeof(struct virtio_net_hdr);
408 		vp->rx_header_size = sizeof(struct virtio_net_hdr);
409 		vp->dev->hw_features |= (NETIF_F_TSO | NETIF_F_GRO);
410 		vp->dev->features |=
411 			(NETIF_F_RXCSUM | NETIF_F_HW_CSUM |
412 				NETIF_F_TSO | NETIF_F_GRO);
413 		netdev_info(
414 			vp->dev,
415 			"raw: using vnet headers for tso and tx/rx checksum"
416 		);
417 	}
418 	return 0;
419 }
420 
421 static int build_hybrid_transport_data(struct vector_private *vp)
422 {
423 	if (uml_raw_enable_vnet_headers(vp->fds->rx_fd)) {
424 		vp->form_header = &raw_form_header;
425 		vp->verify_header = &raw_verify_header;
426 		vp->header_size = sizeof(struct virtio_net_hdr);
427 		vp->rx_header_size = sizeof(struct virtio_net_hdr);
428 		vp->dev->hw_features |=
429 			(NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GRO);
430 		vp->dev->features |=
431 			(NETIF_F_RXCSUM | NETIF_F_HW_CSUM |
432 				NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GRO);
433 		netdev_info(
434 			vp->dev,
435 			"tap/raw hybrid: using vnet headers for tso and tx/rx checksum"
436 		);
437 	} else {
438 		return 0; /* do not try to enable tap too if raw failed */
439 	}
440 	if (uml_tap_enable_vnet_headers(vp->fds->tx_fd))
441 		return 0;
442 	return -1;
443 }
444 
445 static int build_tap_transport_data(struct vector_private *vp)
446 {
447 	/* "Pure" tap uses the same fd for rx and tx */
448 	if (uml_tap_enable_vnet_headers(vp->fds->tx_fd)) {
449 		vp->form_header = &raw_form_header;
450 		vp->verify_header = &raw_verify_header;
451 		vp->header_size = sizeof(struct virtio_net_hdr);
452 		vp->rx_header_size = sizeof(struct virtio_net_hdr);
453 		vp->dev->hw_features |=
454 			(NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GRO);
455 		vp->dev->features |=
456 			(NETIF_F_RXCSUM | NETIF_F_HW_CSUM |
457 				NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GRO);
458 		netdev_info(
459 			vp->dev,
460 			"tap: using vnet headers for tso and tx/rx checksum"
461 		);
462 		return 0;
463 	}
464 	return -1;
465 }
466 
467 
468 static int build_bess_transport_data(struct vector_private *vp)
469 {
470 	vp->form_header = NULL;
471 	vp->verify_header = NULL;
472 	vp->header_size = 0;
473 	vp->rx_header_size = 0;
474 	return 0;
475 }
476 
477 int build_transport_data(struct vector_private *vp)
478 {
479 	char *transport = uml_vector_fetch_arg(vp->parsed, "transport");
480 
481 	if (strncmp(transport, TRANS_GRE, TRANS_GRE_LEN) == 0)
482 		return build_gre_transport_data(vp);
483 	if (strncmp(transport, TRANS_L2TPV3, TRANS_L2TPV3_LEN) == 0)
484 		return build_l2tpv3_transport_data(vp);
485 	if (strncmp(transport, TRANS_RAW, TRANS_RAW_LEN) == 0)
486 		return build_raw_transport_data(vp);
487 	if (strncmp(transport, TRANS_TAP, TRANS_TAP_LEN) == 0)
488 		return build_tap_transport_data(vp);
489 	if (strncmp(transport, TRANS_HYBRID, TRANS_HYBRID_LEN) == 0)
490 		return build_hybrid_transport_data(vp);
491 	if (strncmp(transport, TRANS_BESS, TRANS_BESS_LEN) == 0)
492 		return build_bess_transport_data(vp);
493 	return 0;
494 }
495 
496