2 * QEMU TX packets abstractions
4 * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
6 * Developed by Daynix Computing LTD (http://www.daynix.com)
9 * Dmitry Fleytman <dmitry@daynix.com>
10 * Tamir Shomer <tamirs@daynix.com>
11 * Yan Vugenfirer <yan@daynix.com>
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.
18 #include "net_tx_pkt.h"
20 #include "net/checksum.h"
25 NET_TX_PKT_VHDR_FRAG
= 0,
26 NET_TX_PKT_L2HDR_FRAG
,
27 NET_TX_PKT_L3HDR_FRAG
,
28 NET_TX_PKT_PL_START_FRAG
31 /* TX packet private context */
33 struct virtio_net_hdr virt_hdr
;
38 uint32_t max_raw_frags
;
42 uint8_t l2_hdr
[ETH_MAX_L2_HDR_LEN
];
43 uint8_t l3_hdr
[ETH_MAX_IP_DGRAM_LEN
];
47 uint32_t payload_frags
;
48 uint32_t max_payload_frags
;
51 eth_pkt_types_e packet_type
;
57 void net_tx_pkt_init(struct NetTxPkt
**pkt
, uint32_t max_frags
,
60 struct NetTxPkt
*p
= g_malloc0(sizeof *p
);
62 p
->vec
= g_malloc((sizeof *p
->vec
) *
63 (max_frags
+ NET_TX_PKT_PL_START_FRAG
));
65 p
->raw
= g_malloc((sizeof *p
->raw
) * max_frags
);
67 p
->max_payload_frags
= max_frags
;
68 p
->max_raw_frags
= max_frags
;
69 p
->has_virt_hdr
= has_virt_hdr
;
70 p
->vec
[NET_TX_PKT_VHDR_FRAG
].iov_base
= &p
->virt_hdr
;
71 p
->vec
[NET_TX_PKT_VHDR_FRAG
].iov_len
=
72 p
->has_virt_hdr
? sizeof p
->virt_hdr
: 0;
73 p
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_base
= &p
->l2_hdr
;
74 p
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
= &p
->l3_hdr
;
79 void net_tx_pkt_uninit(struct NetTxPkt
*pkt
)
88 void net_tx_pkt_update_ip_hdr_checksum(struct NetTxPkt
*pkt
)
92 struct ip_header
*ip_hdr
;
93 ip_hdr
= pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
;
95 ip_hdr
->ip_len
= cpu_to_be16(pkt
->payload_len
+
96 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
);
99 csum
= net_raw_checksum((uint8_t *)ip_hdr
,
100 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
);
101 ip_hdr
->ip_sum
= cpu_to_be16(csum
);
104 void net_tx_pkt_update_ip_checksums(struct NetTxPkt
*pkt
)
109 uint8_t gso_type
= pkt
->virt_hdr
.gso_type
& ~VIRTIO_NET_HDR_GSO_ECN
;
110 void *ip_hdr
= pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
;
112 if (pkt
->payload_len
+ pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
>
113 ETH_MAX_IP_DGRAM_LEN
) {
117 if (gso_type
== VIRTIO_NET_HDR_GSO_TCPV4
||
118 gso_type
== VIRTIO_NET_HDR_GSO_UDP
) {
119 /* Calculate IP header checksum */
120 net_tx_pkt_update_ip_hdr_checksum(pkt
);
122 /* Calculate IP pseudo header checksum */
123 cntr
= eth_calc_ip4_pseudo_hdr_csum(ip_hdr
, pkt
->payload_len
, &cso
);
124 csum
= cpu_to_be16(~net_checksum_finish(cntr
));
125 } else if (gso_type
== VIRTIO_NET_HDR_GSO_TCPV6
) {
126 /* Calculate IP pseudo header checksum */
127 cntr
= eth_calc_ip6_pseudo_hdr_csum(ip_hdr
, pkt
->payload_len
,
129 csum
= cpu_to_be16(~net_checksum_finish(cntr
));
134 iov_from_buf(&pkt
->vec
[NET_TX_PKT_PL_START_FRAG
], pkt
->payload_frags
,
135 pkt
->virt_hdr
.csum_offset
, &csum
, sizeof(csum
));
138 static void net_tx_pkt_calculate_hdr_len(struct NetTxPkt
*pkt
)
140 pkt
->hdr_len
= pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
+
141 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
;
144 static bool net_tx_pkt_parse_headers(struct NetTxPkt
*pkt
)
146 struct iovec
*l2_hdr
, *l3_hdr
;
148 size_t full_ip6hdr_len
;
153 l2_hdr
= &pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
];
154 l3_hdr
= &pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
];
156 bytes_read
= iov_to_buf(pkt
->raw
, pkt
->raw_frags
, 0, l2_hdr
->iov_base
,
158 if (bytes_read
< sizeof(struct eth_header
)) {
163 l2_hdr
->iov_len
= sizeof(struct eth_header
);
164 switch (be16_to_cpu(PKT_GET_ETH_HDR(l2_hdr
->iov_base
)->h_proto
)) {
166 l2_hdr
->iov_len
+= sizeof(struct vlan_header
);
169 l2_hdr
->iov_len
+= 2 * sizeof(struct vlan_header
);
173 if (bytes_read
< l2_hdr
->iov_len
) {
176 pkt
->packet_type
= ETH_PKT_UCAST
;
179 l2_hdr
->iov_len
= ETH_MAX_L2_HDR_LEN
;
180 l2_hdr
->iov_len
= eth_get_l2_hdr_length(l2_hdr
->iov_base
);
181 pkt
->packet_type
= get_eth_packet_type(l2_hdr
->iov_base
);
184 l3_proto
= eth_get_l3_proto(l2_hdr
, 1, l2_hdr
->iov_len
);
188 bytes_read
= iov_to_buf(pkt
->raw
, pkt
->raw_frags
, l2_hdr
->iov_len
,
189 l3_hdr
->iov_base
, sizeof(struct ip_header
));
191 if (bytes_read
< sizeof(struct ip_header
)) {
196 l3_hdr
->iov_len
= IP_HDR_GET_LEN(l3_hdr
->iov_base
);
198 if (l3_hdr
->iov_len
< sizeof(struct ip_header
)) {
203 pkt
->l4proto
= ((struct ip_header
*) l3_hdr
->iov_base
)->ip_p
;
205 if (IP_HDR_GET_LEN(l3_hdr
->iov_base
) != sizeof(struct ip_header
)) {
206 /* copy optional IPv4 header data if any*/
207 bytes_read
= iov_to_buf(pkt
->raw
, pkt
->raw_frags
,
208 l2_hdr
->iov_len
+ sizeof(struct ip_header
),
209 l3_hdr
->iov_base
+ sizeof(struct ip_header
),
210 l3_hdr
->iov_len
- sizeof(struct ip_header
));
211 if (bytes_read
< l3_hdr
->iov_len
- sizeof(struct ip_header
)) {
221 eth_ip6_hdr_info hdrinfo
;
223 if (!eth_parse_ipv6_hdr(pkt
->raw
, pkt
->raw_frags
, l2_hdr
->iov_len
,
229 pkt
->l4proto
= hdrinfo
.l4proto
;
230 full_ip6hdr_len
= hdrinfo
.full_hdr_len
;
232 if (full_ip6hdr_len
> ETH_MAX_IP_DGRAM_LEN
) {
237 bytes_read
= iov_to_buf(pkt
->raw
, pkt
->raw_frags
, l2_hdr
->iov_len
,
238 l3_hdr
->iov_base
, full_ip6hdr_len
);
240 if (bytes_read
< full_ip6hdr_len
) {
244 l3_hdr
->iov_len
= full_ip6hdr_len
;
253 net_tx_pkt_calculate_hdr_len(pkt
);
257 static void net_tx_pkt_rebuild_payload(struct NetTxPkt
*pkt
)
259 pkt
->payload_len
= iov_size(pkt
->raw
, pkt
->raw_frags
) - pkt
->hdr_len
;
260 pkt
->payload_frags
= iov_copy(&pkt
->vec
[NET_TX_PKT_PL_START_FRAG
],
261 pkt
->max_payload_frags
,
262 pkt
->raw
, pkt
->raw_frags
,
263 pkt
->hdr_len
, pkt
->payload_len
);
266 bool net_tx_pkt_parse(struct NetTxPkt
*pkt
)
268 if (net_tx_pkt_parse_headers(pkt
)) {
269 net_tx_pkt_rebuild_payload(pkt
);
276 struct virtio_net_hdr
*net_tx_pkt_get_vhdr(struct NetTxPkt
*pkt
)
279 return &pkt
->virt_hdr
;
282 static uint8_t net_tx_pkt_get_gso_type(struct NetTxPkt
*pkt
,
285 uint8_t rc
= VIRTIO_NET_HDR_GSO_NONE
;
288 l3_proto
= eth_get_l3_proto(&pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
], 1,
289 pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
);
295 rc
= eth_get_gso_type(l3_proto
, pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
,
302 void net_tx_pkt_build_vheader(struct NetTxPkt
*pkt
, bool tso_enable
,
303 bool csum_enable
, uint32_t gso_size
)
305 struct tcp_hdr l4hdr
;
308 /* csum has to be enabled if tso is. */
309 assert(csum_enable
|| !tso_enable
);
311 pkt
->virt_hdr
.gso_type
= net_tx_pkt_get_gso_type(pkt
, tso_enable
);
313 switch (pkt
->virt_hdr
.gso_type
& ~VIRTIO_NET_HDR_GSO_ECN
) {
314 case VIRTIO_NET_HDR_GSO_NONE
:
315 pkt
->virt_hdr
.hdr_len
= 0;
316 pkt
->virt_hdr
.gso_size
= 0;
319 case VIRTIO_NET_HDR_GSO_UDP
:
320 pkt
->virt_hdr
.gso_size
= gso_size
;
321 pkt
->virt_hdr
.hdr_len
= pkt
->hdr_len
+ sizeof(struct udp_header
);
324 case VIRTIO_NET_HDR_GSO_TCPV4
:
325 case VIRTIO_NET_HDR_GSO_TCPV6
:
326 iov_to_buf(&pkt
->vec
[NET_TX_PKT_PL_START_FRAG
], pkt
->payload_frags
,
327 0, &l4hdr
, sizeof(l4hdr
));
328 pkt
->virt_hdr
.hdr_len
= pkt
->hdr_len
+ l4hdr
.th_off
* sizeof(uint32_t);
329 pkt
->virt_hdr
.gso_size
= gso_size
;
333 g_assert_not_reached();
337 switch (pkt
->l4proto
) {
339 pkt
->virt_hdr
.flags
= VIRTIO_NET_HDR_F_NEEDS_CSUM
;
340 pkt
->virt_hdr
.csum_start
= pkt
->hdr_len
;
341 pkt
->virt_hdr
.csum_offset
= offsetof(struct tcp_hdr
, th_sum
);
344 pkt
->virt_hdr
.flags
= VIRTIO_NET_HDR_F_NEEDS_CSUM
;
345 pkt
->virt_hdr
.csum_start
= pkt
->hdr_len
;
346 pkt
->virt_hdr
.csum_offset
= offsetof(struct udp_hdr
, uh_sum
);
354 void net_tx_pkt_setup_vlan_header_ex(struct NetTxPkt
*pkt
,
355 uint16_t vlan
, uint16_t vlan_ethtype
)
360 eth_setup_vlan_headers_ex(pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_base
,
361 vlan
, vlan_ethtype
, &is_new
);
363 /* update l2hdrlen */
365 pkt
->hdr_len
+= sizeof(struct vlan_header
);
366 pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
+=
367 sizeof(struct vlan_header
);
371 bool net_tx_pkt_add_raw_fragment(struct NetTxPkt
*pkt
, hwaddr pa
,
374 hwaddr mapped_len
= 0;
375 struct iovec
*ventry
;
377 assert(pkt
->max_raw_frags
> pkt
->raw_frags
);
383 ventry
= &pkt
->raw
[pkt
->raw_frags
];
386 ventry
->iov_base
= cpu_physical_memory_map(pa
, &mapped_len
, false);
388 if ((ventry
->iov_base
!= NULL
) && (len
== mapped_len
)) {
389 ventry
->iov_len
= mapped_len
;
397 bool net_tx_pkt_has_fragments(struct NetTxPkt
*pkt
)
399 return pkt
->raw_frags
> 0;
402 eth_pkt_types_e
net_tx_pkt_get_packet_type(struct NetTxPkt
*pkt
)
406 return pkt
->packet_type
;
409 size_t net_tx_pkt_get_total_len(struct NetTxPkt
*pkt
)
413 return pkt
->hdr_len
+ pkt
->payload_len
;
416 void net_tx_pkt_dump(struct NetTxPkt
*pkt
)
418 #ifdef NET_TX_PKT_DEBUG
421 printf("TX PKT: hdr_len: %d, pkt_type: 0x%X, l2hdr_len: %lu, "
422 "l3hdr_len: %lu, payload_len: %u\n", pkt
->hdr_len
, pkt
->packet_type
,
423 pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
,
424 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
, pkt
->payload_len
);
428 void net_tx_pkt_reset(struct NetTxPkt
*pkt
)
432 /* no assert, as reset can be called before tx_pkt_init */
437 memset(&pkt
->virt_hdr
, 0, sizeof(pkt
->virt_hdr
));
441 pkt
->payload_len
= 0;
442 pkt
->payload_frags
= 0;
445 for (i
= 0; i
< pkt
->raw_frags
; i
++) {
446 assert(pkt
->raw
[i
].iov_base
);
447 cpu_physical_memory_unmap(pkt
->raw
[i
].iov_base
, pkt
->raw
[i
].iov_len
,
448 false, pkt
->raw
[i
].iov_len
);
456 static void net_tx_pkt_do_sw_csum(struct NetTxPkt
*pkt
)
458 struct iovec
*iov
= &pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
];
462 /* num of iovec without vhdr */
463 uint32_t iov_len
= pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
- 1;
465 struct ip_header
*iphdr
;
466 size_t csum_offset
= pkt
->virt_hdr
.csum_start
+ pkt
->virt_hdr
.csum_offset
;
468 /* Put zero to checksum field */
469 iov_from_buf(iov
, iov_len
, csum_offset
, &csum
, sizeof csum
);
471 /* Calculate L4 TCP/UDP checksum */
472 csl
= pkt
->payload_len
;
474 /* add pseudo header to csum */
475 iphdr
= pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
;
476 csum_cntr
= eth_calc_ip4_pseudo_hdr_csum(iphdr
, csl
, &cso
);
480 net_checksum_add_iov(iov
, iov_len
, pkt
->virt_hdr
.csum_start
, csl
, cso
);
482 /* Put the checksum obtained into the packet */
483 csum
= cpu_to_be16(net_checksum_finish(csum_cntr
));
484 iov_from_buf(iov
, iov_len
, csum_offset
, &csum
, sizeof csum
);
488 NET_TX_PKT_FRAGMENT_L2_HDR_POS
= 0,
489 NET_TX_PKT_FRAGMENT_L3_HDR_POS
,
490 NET_TX_PKT_FRAGMENT_HEADER_NUM
493 #define NET_MAX_FRAG_SG_LIST (64)
495 static size_t net_tx_pkt_fetch_fragment(struct NetTxPkt
*pkt
,
496 int *src_idx
, size_t *src_offset
, struct iovec
*dst
, int *dst_idx
)
499 struct iovec
*src
= pkt
->vec
;
501 *dst_idx
= NET_TX_PKT_FRAGMENT_HEADER_NUM
;
503 while (fetched
< IP_FRAG_ALIGN_SIZE(pkt
->virt_hdr
.gso_size
)) {
505 /* no more place in fragment iov */
506 if (*dst_idx
== NET_MAX_FRAG_SG_LIST
) {
510 /* no more data in iovec */
511 if (*src_idx
== (pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
)) {
516 dst
[*dst_idx
].iov_base
= src
[*src_idx
].iov_base
+ *src_offset
;
517 dst
[*dst_idx
].iov_len
= MIN(src
[*src_idx
].iov_len
- *src_offset
,
518 IP_FRAG_ALIGN_SIZE(pkt
->virt_hdr
.gso_size
) - fetched
);
520 *src_offset
+= dst
[*dst_idx
].iov_len
;
521 fetched
+= dst
[*dst_idx
].iov_len
;
523 if (*src_offset
== src
[*src_idx
].iov_len
) {
534 static inline void net_tx_pkt_sendv(struct NetTxPkt
*pkt
,
535 NetClientState
*nc
, const struct iovec
*iov
, int iov_cnt
)
537 if (pkt
->is_loopback
) {
538 nc
->info
->receive_iov(nc
, iov
, iov_cnt
);
540 qemu_sendv_packet(nc
, iov
, iov_cnt
);
544 static bool net_tx_pkt_do_sw_fragmentation(struct NetTxPkt
*pkt
,
547 struct iovec fragment
[NET_MAX_FRAG_SG_LIST
];
548 size_t fragment_len
= 0;
549 bool more_frags
= false;
551 /* some pointers for shorter code */
552 void *l2_iov_base
, *l3_iov_base
;
553 size_t l2_iov_len
, l3_iov_len
;
554 int src_idx
= NET_TX_PKT_PL_START_FRAG
, dst_idx
;
555 size_t src_offset
= 0;
556 size_t fragment_offset
= 0;
558 l2_iov_base
= pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_base
;
559 l2_iov_len
= pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
;
560 l3_iov_base
= pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
;
561 l3_iov_len
= pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
;
564 fragment
[NET_TX_PKT_FRAGMENT_L2_HDR_POS
].iov_base
= l2_iov_base
;
565 fragment
[NET_TX_PKT_FRAGMENT_L2_HDR_POS
].iov_len
= l2_iov_len
;
566 fragment
[NET_TX_PKT_FRAGMENT_L3_HDR_POS
].iov_base
= l3_iov_base
;
567 fragment
[NET_TX_PKT_FRAGMENT_L3_HDR_POS
].iov_len
= l3_iov_len
;
570 /* Put as much data as possible and send */
572 fragment_len
= net_tx_pkt_fetch_fragment(pkt
, &src_idx
, &src_offset
,
575 more_frags
= (fragment_offset
+ fragment_len
< pkt
->payload_len
);
577 eth_setup_ip4_fragmentation(l2_iov_base
, l2_iov_len
, l3_iov_base
,
578 l3_iov_len
, fragment_len
, fragment_offset
, more_frags
);
580 eth_fix_ip4_checksum(l3_iov_base
, l3_iov_len
);
582 net_tx_pkt_sendv(pkt
, nc
, fragment
, dst_idx
);
584 fragment_offset
+= fragment_len
;
586 } while (more_frags
);
591 bool net_tx_pkt_send(struct NetTxPkt
*pkt
, NetClientState
*nc
)
595 if (!pkt
->has_virt_hdr
&&
596 pkt
->virt_hdr
.flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) {
597 net_tx_pkt_do_sw_csum(pkt
);
601 * Since underlying infrastructure does not support IP datagrams longer
602 * than 64K we should drop such packets and don't even try to send
604 if (VIRTIO_NET_HDR_GSO_NONE
!= pkt
->virt_hdr
.gso_type
) {
605 if (pkt
->payload_len
>
606 ETH_MAX_IP_DGRAM_LEN
-
607 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
) {
612 if (pkt
->has_virt_hdr
||
613 pkt
->virt_hdr
.gso_type
== VIRTIO_NET_HDR_GSO_NONE
) {
614 net_tx_pkt_sendv(pkt
, nc
, pkt
->vec
,
615 pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
);
619 return net_tx_pkt_do_sw_fragmentation(pkt
, nc
);
622 bool net_tx_pkt_send_loopback(struct NetTxPkt
*pkt
, NetClientState
*nc
)
626 pkt
->is_loopback
= true;
627 res
= net_tx_pkt_send(pkt
, nc
);
628 pkt
->is_loopback
= false;