tests/acpi: add new unit test to test hotplug off/on feature on the root pci bus
[qemu.git] / net / eth.c
1 /*
2 * QEMU network structures definitions and helper functions
3 *
4 * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
5 *
6 * Developed by Daynix Computing LTD (http://www.daynix.com)
7 *
8 * Authors:
9 * Dmitry Fleytman <dmitry@daynix.com>
10 * Tamir Shomer <tamirs@daynix.com>
11 * Yan Vugenfirer <yan@daynix.com>
12 *
13 * This work is licensed under the terms of the GNU GPL, version 2 or later.
14 * See the COPYING file in the top-level directory.
15 *
16 */
17
18 #include "qemu/osdep.h"
19 #include "net/eth.h"
20 #include "net/checksum.h"
21 #include "net/tap.h"
22
23 void eth_setup_vlan_headers_ex(struct eth_header *ehdr, uint16_t vlan_tag,
24 uint16_t vlan_ethtype, bool *is_new)
25 {
26 struct vlan_header *vhdr = PKT_GET_VLAN_HDR(ehdr);
27
28 switch (be16_to_cpu(ehdr->h_proto)) {
29 case ETH_P_VLAN:
30 case ETH_P_DVLAN:
31 /* vlan hdr exists */
32 *is_new = false;
33 break;
34
35 default:
36 /* No VLAN header, put a new one */
37 vhdr->h_proto = ehdr->h_proto;
38 ehdr->h_proto = cpu_to_be16(vlan_ethtype);
39 *is_new = true;
40 break;
41 }
42 vhdr->h_tci = cpu_to_be16(vlan_tag);
43 }
44
45 uint8_t
46 eth_get_gso_type(uint16_t l3_proto, uint8_t *l3_hdr, uint8_t l4proto)
47 {
48 uint8_t ecn_state = 0;
49
50 if (l3_proto == ETH_P_IP) {
51 struct ip_header *iphdr = (struct ip_header *) l3_hdr;
52
53 if (IP_HEADER_VERSION(iphdr) == IP_HEADER_VERSION_4) {
54 if (IPTOS_ECN(iphdr->ip_tos) == IPTOS_ECN_CE) {
55 ecn_state = VIRTIO_NET_HDR_GSO_ECN;
56 }
57 if (l4proto == IP_PROTO_TCP) {
58 return VIRTIO_NET_HDR_GSO_TCPV4 | ecn_state;
59 } else if (l4proto == IP_PROTO_UDP) {
60 return VIRTIO_NET_HDR_GSO_UDP | ecn_state;
61 }
62 }
63 } else if (l3_proto == ETH_P_IPV6) {
64 struct ip6_header *ip6hdr = (struct ip6_header *) l3_hdr;
65
66 if (IP6_ECN(ip6hdr->ip6_ecn_acc) == IP6_ECN_CE) {
67 ecn_state = VIRTIO_NET_HDR_GSO_ECN;
68 }
69
70 if (l4proto == IP_PROTO_TCP) {
71 return VIRTIO_NET_HDR_GSO_TCPV6 | ecn_state;
72 }
73 }
74
75 /* Unsupported offload */
76 g_assert_not_reached();
77
78 return VIRTIO_NET_HDR_GSO_NONE | ecn_state;
79 }
80
81 uint16_t
82 eth_get_l3_proto(const struct iovec *l2hdr_iov, int iovcnt, size_t l2hdr_len)
83 {
84 uint16_t proto;
85 size_t copied;
86 size_t size = iov_size(l2hdr_iov, iovcnt);
87 size_t proto_offset = l2hdr_len - sizeof(proto);
88
89 if (size < proto_offset) {
90 return ETH_P_UNKNOWN;
91 }
92
93 copied = iov_to_buf(l2hdr_iov, iovcnt, proto_offset,
94 &proto, sizeof(proto));
95
96 return (copied == sizeof(proto)) ? be16_to_cpu(proto) : ETH_P_UNKNOWN;
97 }
98
99 static bool
100 _eth_copy_chunk(size_t input_size,
101 const struct iovec *iov, int iovcnt,
102 size_t offset, size_t length,
103 void *buffer)
104 {
105 size_t copied;
106
107 if (input_size < offset) {
108 return false;
109 }
110
111 copied = iov_to_buf(iov, iovcnt, offset, buffer, length);
112
113 if (copied < length) {
114 return false;
115 }
116
117 return true;
118 }
119
120 static bool
121 _eth_tcp_has_data(bool is_ip4,
122 const struct ip_header *ip4_hdr,
123 const struct ip6_header *ip6_hdr,
124 size_t full_ip6hdr_len,
125 const struct tcp_header *tcp)
126 {
127 uint32_t l4len;
128
129 if (is_ip4) {
130 l4len = be16_to_cpu(ip4_hdr->ip_len) - IP_HDR_GET_LEN(ip4_hdr);
131 } else {
132 size_t opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
133 l4len = be16_to_cpu(ip6_hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) - opts_len;
134 }
135
136 return l4len > TCP_HEADER_DATA_OFFSET(tcp);
137 }
138
139 void eth_get_protocols(const struct iovec *iov, int iovcnt,
140 bool *isip4, bool *isip6,
141 bool *isudp, bool *istcp,
142 size_t *l3hdr_off,
143 size_t *l4hdr_off,
144 size_t *l5hdr_off,
145 eth_ip6_hdr_info *ip6hdr_info,
146 eth_ip4_hdr_info *ip4hdr_info,
147 eth_l4_hdr_info *l4hdr_info)
148 {
149 int proto;
150 bool fragment = false;
151 size_t l2hdr_len = eth_get_l2_hdr_length_iov(iov, iovcnt);
152 size_t input_size = iov_size(iov, iovcnt);
153 size_t copied;
154
155 *isip4 = *isip6 = *isudp = *istcp = false;
156
157 proto = eth_get_l3_proto(iov, iovcnt, l2hdr_len);
158
159 *l3hdr_off = l2hdr_len;
160
161 if (proto == ETH_P_IP) {
162 struct ip_header *iphdr = &ip4hdr_info->ip4_hdr;
163
164 if (input_size < l2hdr_len) {
165 return;
166 }
167
168 copied = iov_to_buf(iov, iovcnt, l2hdr_len, iphdr, sizeof(*iphdr));
169
170 *isip4 = true;
171
172 if (copied < sizeof(*iphdr)) {
173 return;
174 }
175
176 if (IP_HEADER_VERSION(iphdr) == IP_HEADER_VERSION_4) {
177 if (iphdr->ip_p == IP_PROTO_TCP) {
178 *istcp = true;
179 } else if (iphdr->ip_p == IP_PROTO_UDP) {
180 *isudp = true;
181 }
182 }
183
184 ip4hdr_info->fragment = IP4_IS_FRAGMENT(iphdr);
185 *l4hdr_off = l2hdr_len + IP_HDR_GET_LEN(iphdr);
186
187 fragment = ip4hdr_info->fragment;
188 } else if (proto == ETH_P_IPV6) {
189
190 *isip6 = true;
191 if (eth_parse_ipv6_hdr(iov, iovcnt, l2hdr_len,
192 ip6hdr_info)) {
193 if (ip6hdr_info->l4proto == IP_PROTO_TCP) {
194 *istcp = true;
195 } else if (ip6hdr_info->l4proto == IP_PROTO_UDP) {
196 *isudp = true;
197 }
198 } else {
199 return;
200 }
201
202 *l4hdr_off = l2hdr_len + ip6hdr_info->full_hdr_len;
203 fragment = ip6hdr_info->fragment;
204 }
205
206 if (!fragment) {
207 if (*istcp) {
208 *istcp = _eth_copy_chunk(input_size,
209 iov, iovcnt,
210 *l4hdr_off, sizeof(l4hdr_info->hdr.tcp),
211 &l4hdr_info->hdr.tcp);
212
213 if (*istcp) {
214 *l5hdr_off = *l4hdr_off +
215 TCP_HEADER_DATA_OFFSET(&l4hdr_info->hdr.tcp);
216
217 l4hdr_info->has_tcp_data =
218 _eth_tcp_has_data(proto == ETH_P_IP,
219 &ip4hdr_info->ip4_hdr,
220 &ip6hdr_info->ip6_hdr,
221 *l4hdr_off - *l3hdr_off,
222 &l4hdr_info->hdr.tcp);
223 }
224 } else if (*isudp) {
225 *isudp = _eth_copy_chunk(input_size,
226 iov, iovcnt,
227 *l4hdr_off, sizeof(l4hdr_info->hdr.udp),
228 &l4hdr_info->hdr.udp);
229 *l5hdr_off = *l4hdr_off + sizeof(l4hdr_info->hdr.udp);
230 }
231 }
232 }
233
234 size_t
235 eth_strip_vlan(const struct iovec *iov, int iovcnt, size_t iovoff,
236 uint8_t *new_ehdr_buf,
237 uint16_t *payload_offset, uint16_t *tci)
238 {
239 struct vlan_header vlan_hdr;
240 struct eth_header *new_ehdr = (struct eth_header *) new_ehdr_buf;
241
242 size_t copied = iov_to_buf(iov, iovcnt, iovoff,
243 new_ehdr, sizeof(*new_ehdr));
244
245 if (copied < sizeof(*new_ehdr)) {
246 return 0;
247 }
248
249 switch (be16_to_cpu(new_ehdr->h_proto)) {
250 case ETH_P_VLAN:
251 case ETH_P_DVLAN:
252 copied = iov_to_buf(iov, iovcnt, iovoff + sizeof(*new_ehdr),
253 &vlan_hdr, sizeof(vlan_hdr));
254
255 if (copied < sizeof(vlan_hdr)) {
256 return 0;
257 }
258
259 new_ehdr->h_proto = vlan_hdr.h_proto;
260
261 *tci = be16_to_cpu(vlan_hdr.h_tci);
262 *payload_offset = iovoff + sizeof(*new_ehdr) + sizeof(vlan_hdr);
263
264 if (be16_to_cpu(new_ehdr->h_proto) == ETH_P_VLAN) {
265
266 copied = iov_to_buf(iov, iovcnt, *payload_offset,
267 PKT_GET_VLAN_HDR(new_ehdr), sizeof(vlan_hdr));
268
269 if (copied < sizeof(vlan_hdr)) {
270 return 0;
271 }
272
273 *payload_offset += sizeof(vlan_hdr);
274
275 return sizeof(struct eth_header) + sizeof(struct vlan_header);
276 } else {
277 return sizeof(struct eth_header);
278 }
279 default:
280 return 0;
281 }
282 }
283
284 size_t
285 eth_strip_vlan_ex(const struct iovec *iov, int iovcnt, size_t iovoff,
286 uint16_t vet, uint8_t *new_ehdr_buf,
287 uint16_t *payload_offset, uint16_t *tci)
288 {
289 struct vlan_header vlan_hdr;
290 struct eth_header *new_ehdr = (struct eth_header *) new_ehdr_buf;
291
292 size_t copied = iov_to_buf(iov, iovcnt, iovoff,
293 new_ehdr, sizeof(*new_ehdr));
294
295 if (copied < sizeof(*new_ehdr)) {
296 return 0;
297 }
298
299 if (be16_to_cpu(new_ehdr->h_proto) == vet) {
300 copied = iov_to_buf(iov, iovcnt, iovoff + sizeof(*new_ehdr),
301 &vlan_hdr, sizeof(vlan_hdr));
302
303 if (copied < sizeof(vlan_hdr)) {
304 return 0;
305 }
306
307 new_ehdr->h_proto = vlan_hdr.h_proto;
308
309 *tci = be16_to_cpu(vlan_hdr.h_tci);
310 *payload_offset = iovoff + sizeof(*new_ehdr) + sizeof(vlan_hdr);
311 return sizeof(struct eth_header);
312 }
313
314 return 0;
315 }
316
317 void
318 eth_setup_ip4_fragmentation(const void *l2hdr, size_t l2hdr_len,
319 void *l3hdr, size_t l3hdr_len,
320 size_t l3payload_len,
321 size_t frag_offset, bool more_frags)
322 {
323 const struct iovec l2vec = {
324 .iov_base = (void *) l2hdr,
325 .iov_len = l2hdr_len
326 };
327
328 if (eth_get_l3_proto(&l2vec, 1, l2hdr_len) == ETH_P_IP) {
329 uint16_t orig_flags;
330 struct ip_header *iphdr = (struct ip_header *) l3hdr;
331 uint16_t frag_off_units = frag_offset / IP_FRAG_UNIT_SIZE;
332 uint16_t new_ip_off;
333
334 assert(frag_offset % IP_FRAG_UNIT_SIZE == 0);
335 assert((frag_off_units & ~IP_OFFMASK) == 0);
336
337 orig_flags = be16_to_cpu(iphdr->ip_off) & ~(IP_OFFMASK|IP_MF);
338 new_ip_off = frag_off_units | orig_flags | (more_frags ? IP_MF : 0);
339 iphdr->ip_off = cpu_to_be16(new_ip_off);
340 iphdr->ip_len = cpu_to_be16(l3payload_len + l3hdr_len);
341 }
342 }
343
344 void
345 eth_fix_ip4_checksum(void *l3hdr, size_t l3hdr_len)
346 {
347 struct ip_header *iphdr = (struct ip_header *) l3hdr;
348 iphdr->ip_sum = 0;
349 iphdr->ip_sum = cpu_to_be16(net_raw_checksum(l3hdr, l3hdr_len));
350 }
351
352 uint32_t
353 eth_calc_ip4_pseudo_hdr_csum(struct ip_header *iphdr,
354 uint16_t csl,
355 uint32_t *cso)
356 {
357 struct ip_pseudo_header ipph;
358 ipph.ip_src = iphdr->ip_src;
359 ipph.ip_dst = iphdr->ip_dst;
360 ipph.ip_payload = cpu_to_be16(csl);
361 ipph.ip_proto = iphdr->ip_p;
362 ipph.zeros = 0;
363 *cso = sizeof(ipph);
364 return net_checksum_add(*cso, (uint8_t *) &ipph);
365 }
366
367 uint32_t
368 eth_calc_ip6_pseudo_hdr_csum(struct ip6_header *iphdr,
369 uint16_t csl,
370 uint8_t l4_proto,
371 uint32_t *cso)
372 {
373 struct ip6_pseudo_header ipph;
374 ipph.ip6_src = iphdr->ip6_src;
375 ipph.ip6_dst = iphdr->ip6_dst;
376 ipph.len = cpu_to_be16(csl);
377 ipph.zero[0] = 0;
378 ipph.zero[1] = 0;
379 ipph.zero[2] = 0;
380 ipph.next_hdr = l4_proto;
381 *cso = sizeof(ipph);
382 return net_checksum_add(*cso, (uint8_t *)&ipph);
383 }
384
385 static bool
386 eth_is_ip6_extension_header_type(uint8_t hdr_type)
387 {
388 switch (hdr_type) {
389 case IP6_HOP_BY_HOP:
390 case IP6_ROUTING:
391 case IP6_FRAGMENT:
392 case IP6_ESP:
393 case IP6_AUTHENTICATION:
394 case IP6_DESTINATON:
395 case IP6_MOBILITY:
396 return true;
397 default:
398 return false;
399 }
400 }
401
402 static bool
403 _eth_get_rss_ex_dst_addr(const struct iovec *pkt, int pkt_frags,
404 size_t rthdr_offset,
405 struct ip6_ext_hdr *ext_hdr,
406 struct in6_address *dst_addr)
407 {
408 struct ip6_ext_hdr_routing *rthdr = (struct ip6_ext_hdr_routing *) ext_hdr;
409
410 if ((rthdr->rtype == 2) &&
411 (rthdr->len == sizeof(struct in6_address) / 8) &&
412 (rthdr->segleft == 1)) {
413
414 size_t input_size = iov_size(pkt, pkt_frags);
415 size_t bytes_read;
416
417 if (input_size < rthdr_offset + sizeof(*ext_hdr)) {
418 return false;
419 }
420
421 bytes_read = iov_to_buf(pkt, pkt_frags,
422 rthdr_offset + sizeof(*ext_hdr),
423 dst_addr, sizeof(*dst_addr));
424
425 return bytes_read == sizeof(*dst_addr);
426 }
427
428 return false;
429 }
430
431 static bool
432 _eth_get_rss_ex_src_addr(const struct iovec *pkt, int pkt_frags,
433 size_t dsthdr_offset,
434 struct ip6_ext_hdr *ext_hdr,
435 struct in6_address *src_addr)
436 {
437 size_t bytes_left = (ext_hdr->ip6r_len + 1) * 8 - sizeof(*ext_hdr);
438 struct ip6_option_hdr opthdr;
439 size_t opt_offset = dsthdr_offset + sizeof(*ext_hdr);
440
441 while (bytes_left > sizeof(opthdr)) {
442 size_t input_size = iov_size(pkt, pkt_frags);
443 size_t bytes_read, optlen;
444
445 if (input_size < opt_offset) {
446 return false;
447 }
448
449 bytes_read = iov_to_buf(pkt, pkt_frags, opt_offset,
450 &opthdr, sizeof(opthdr));
451
452 if (bytes_read != sizeof(opthdr)) {
453 return false;
454 }
455
456 optlen = (opthdr.type == IP6_OPT_PAD1) ? 1
457 : (opthdr.len + sizeof(opthdr));
458
459 if (optlen > bytes_left) {
460 return false;
461 }
462
463 if (opthdr.type == IP6_OPT_HOME) {
464 size_t input_size = iov_size(pkt, pkt_frags);
465
466 if (input_size < opt_offset + sizeof(opthdr)) {
467 return false;
468 }
469
470 bytes_read = iov_to_buf(pkt, pkt_frags,
471 opt_offset + sizeof(opthdr),
472 src_addr, sizeof(*src_addr));
473
474 return bytes_read == sizeof(*src_addr);
475 }
476
477 opt_offset += optlen;
478 bytes_left -= optlen;
479 }
480
481 return false;
482 }
483
484 bool eth_parse_ipv6_hdr(const struct iovec *pkt, int pkt_frags,
485 size_t ip6hdr_off, eth_ip6_hdr_info *info)
486 {
487 struct ip6_ext_hdr ext_hdr;
488 size_t bytes_read;
489 uint8_t curr_ext_hdr_type;
490 size_t input_size = iov_size(pkt, pkt_frags);
491
492 info->rss_ex_dst_valid = false;
493 info->rss_ex_src_valid = false;
494 info->fragment = false;
495
496 if (input_size < ip6hdr_off) {
497 return false;
498 }
499
500 bytes_read = iov_to_buf(pkt, pkt_frags, ip6hdr_off,
501 &info->ip6_hdr, sizeof(info->ip6_hdr));
502 if (bytes_read < sizeof(info->ip6_hdr)) {
503 return false;
504 }
505
506 info->full_hdr_len = sizeof(struct ip6_header);
507
508 curr_ext_hdr_type = info->ip6_hdr.ip6_nxt;
509
510 if (!eth_is_ip6_extension_header_type(curr_ext_hdr_type)) {
511 info->l4proto = info->ip6_hdr.ip6_nxt;
512 info->has_ext_hdrs = false;
513 return true;
514 }
515
516 info->has_ext_hdrs = true;
517
518 do {
519 if (input_size < ip6hdr_off + info->full_hdr_len) {
520 return false;
521 }
522
523 bytes_read = iov_to_buf(pkt, pkt_frags, ip6hdr_off + info->full_hdr_len,
524 &ext_hdr, sizeof(ext_hdr));
525
526 if (bytes_read < sizeof(ext_hdr)) {
527 return false;
528 }
529
530 if (curr_ext_hdr_type == IP6_ROUTING) {
531 info->rss_ex_dst_valid =
532 _eth_get_rss_ex_dst_addr(pkt, pkt_frags,
533 ip6hdr_off + info->full_hdr_len,
534 &ext_hdr, &info->rss_ex_dst);
535 } else if (curr_ext_hdr_type == IP6_DESTINATON) {
536 info->rss_ex_src_valid =
537 _eth_get_rss_ex_src_addr(pkt, pkt_frags,
538 ip6hdr_off + info->full_hdr_len,
539 &ext_hdr, &info->rss_ex_src);
540 } else if (curr_ext_hdr_type == IP6_FRAGMENT) {
541 info->fragment = true;
542 }
543
544 info->full_hdr_len += (ext_hdr.ip6r_len + 1) * IP6_EXT_GRANULARITY;
545 curr_ext_hdr_type = ext_hdr.ip6r_nxt;
546 } while (eth_is_ip6_extension_header_type(curr_ext_hdr_type));
547
548 info->l4proto = ext_hdr.ip6r_nxt;
549 return true;
550 }