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 "qemu/osdep.h"
19 #include "net_tx_pkt.h"
21 #include "net/checksum.h"
24 #include "hw/pci/pci_device.h"
27 NET_TX_PKT_VHDR_FRAG
= 0,
28 NET_TX_PKT_L2HDR_FRAG
,
29 NET_TX_PKT_L3HDR_FRAG
,
30 NET_TX_PKT_PL_START_FRAG
33 /* TX packet private context */
37 struct virtio_net_hdr virt_hdr
;
41 uint32_t max_raw_frags
;
45 uint8_t l2_hdr
[ETH_MAX_L2_HDR_LEN
];
46 uint8_t l3_hdr
[ETH_MAX_IP_DGRAM_LEN
];
50 uint32_t payload_frags
;
51 uint32_t max_payload_frags
;
54 eth_pkt_types_e packet_type
;
58 void net_tx_pkt_init(struct NetTxPkt
**pkt
, PCIDevice
*pci_dev
,
61 struct NetTxPkt
*p
= g_malloc0(sizeof *p
);
65 p
->vec
= g_new(struct iovec
, max_frags
+ NET_TX_PKT_PL_START_FRAG
);
67 p
->raw
= g_new(struct iovec
, max_frags
);
69 p
->max_payload_frags
= max_frags
;
70 p
->max_raw_frags
= max_frags
;
71 p
->vec
[NET_TX_PKT_VHDR_FRAG
].iov_base
= &p
->virt_hdr
;
72 p
->vec
[NET_TX_PKT_VHDR_FRAG
].iov_len
= sizeof p
->virt_hdr
;
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
= IP_HDR_GET_P(l3_hdr
->iov_base
);
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 bool net_tx_pkt_build_vheader(struct NetTxPkt
*pkt
, bool tso_enable
,
303 bool csum_enable
, uint32_t gso_size
)
305 struct tcp_hdr l4hdr
;
309 /* csum has to be enabled if tso is. */
310 assert(csum_enable
|| !tso_enable
);
312 pkt
->virt_hdr
.gso_type
= net_tx_pkt_get_gso_type(pkt
, tso_enable
);
314 switch (pkt
->virt_hdr
.gso_type
& ~VIRTIO_NET_HDR_GSO_ECN
) {
315 case VIRTIO_NET_HDR_GSO_NONE
:
316 pkt
->virt_hdr
.hdr_len
= 0;
317 pkt
->virt_hdr
.gso_size
= 0;
320 case VIRTIO_NET_HDR_GSO_UDP
:
321 pkt
->virt_hdr
.gso_size
= gso_size
;
322 pkt
->virt_hdr
.hdr_len
= pkt
->hdr_len
+ sizeof(struct udp_header
);
325 case VIRTIO_NET_HDR_GSO_TCPV4
:
326 case VIRTIO_NET_HDR_GSO_TCPV6
:
327 bytes_read
= iov_to_buf(&pkt
->vec
[NET_TX_PKT_PL_START_FRAG
],
328 pkt
->payload_frags
, 0, &l4hdr
, sizeof(l4hdr
));
329 if (bytes_read
< sizeof(l4hdr
) ||
330 l4hdr
.th_off
* sizeof(uint32_t) < sizeof(l4hdr
)) {
334 pkt
->virt_hdr
.hdr_len
= pkt
->hdr_len
+ l4hdr
.th_off
* sizeof(uint32_t);
335 pkt
->virt_hdr
.gso_size
= gso_size
;
339 g_assert_not_reached();
343 switch (pkt
->l4proto
) {
345 pkt
->virt_hdr
.flags
= VIRTIO_NET_HDR_F_NEEDS_CSUM
;
346 pkt
->virt_hdr
.csum_start
= pkt
->hdr_len
;
347 pkt
->virt_hdr
.csum_offset
= offsetof(struct tcp_hdr
, th_sum
);
350 pkt
->virt_hdr
.flags
= VIRTIO_NET_HDR_F_NEEDS_CSUM
;
351 pkt
->virt_hdr
.csum_start
= pkt
->hdr_len
;
352 pkt
->virt_hdr
.csum_offset
= offsetof(struct udp_hdr
, uh_sum
);
362 void net_tx_pkt_setup_vlan_header_ex(struct NetTxPkt
*pkt
,
363 uint16_t vlan
, uint16_t vlan_ethtype
)
368 eth_setup_vlan_headers_ex(pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_base
,
369 vlan
, vlan_ethtype
, &is_new
);
371 /* update l2hdrlen */
373 pkt
->hdr_len
+= sizeof(struct vlan_header
);
374 pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
+=
375 sizeof(struct vlan_header
);
379 bool net_tx_pkt_add_raw_fragment(struct NetTxPkt
*pkt
, hwaddr pa
,
382 hwaddr mapped_len
= 0;
383 struct iovec
*ventry
;
386 if (pkt
->raw_frags
>= pkt
->max_raw_frags
) {
394 ventry
= &pkt
->raw
[pkt
->raw_frags
];
397 ventry
->iov_base
= pci_dma_map(pkt
->pci_dev
, pa
,
398 &mapped_len
, DMA_DIRECTION_TO_DEVICE
);
400 if ((ventry
->iov_base
!= NULL
) && (len
== mapped_len
)) {
401 ventry
->iov_len
= mapped_len
;
409 bool net_tx_pkt_has_fragments(struct NetTxPkt
*pkt
)
411 return pkt
->raw_frags
> 0;
414 eth_pkt_types_e
net_tx_pkt_get_packet_type(struct NetTxPkt
*pkt
)
418 return pkt
->packet_type
;
421 size_t net_tx_pkt_get_total_len(struct NetTxPkt
*pkt
)
425 return pkt
->hdr_len
+ pkt
->payload_len
;
428 void net_tx_pkt_dump(struct NetTxPkt
*pkt
)
430 #ifdef NET_TX_PKT_DEBUG
433 printf("TX PKT: hdr_len: %d, pkt_type: 0x%X, l2hdr_len: %lu, "
434 "l3hdr_len: %lu, payload_len: %u\n", pkt
->hdr_len
, pkt
->packet_type
,
435 pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
].iov_len
,
436 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
, pkt
->payload_len
);
440 void net_tx_pkt_reset(struct NetTxPkt
*pkt
)
444 /* no assert, as reset can be called before tx_pkt_init */
449 memset(&pkt
->virt_hdr
, 0, sizeof(pkt
->virt_hdr
));
453 pkt
->payload_len
= 0;
454 pkt
->payload_frags
= 0;
456 if (pkt
->max_raw_frags
> 0) {
458 for (i
= 0; i
< pkt
->raw_frags
; i
++) {
459 assert(pkt
->raw
[i
].iov_base
);
460 pci_dma_unmap(pkt
->pci_dev
, pkt
->raw
[i
].iov_base
,
461 pkt
->raw
[i
].iov_len
, DMA_DIRECTION_TO_DEVICE
, 0);
470 static void net_tx_pkt_do_sw_csum(struct NetTxPkt
*pkt
,
471 struct iovec
*iov
, uint32_t iov_len
,
477 /* num of iovec without vhdr */
478 size_t csum_offset
= pkt
->virt_hdr
.csum_start
+ pkt
->virt_hdr
.csum_offset
;
479 uint16_t l3_proto
= eth_get_l3_proto(iov
, 1, iov
->iov_len
);
481 /* Put zero to checksum field */
482 iov_from_buf(iov
, iov_len
, csum_offset
, &csum
, sizeof csum
);
484 /* Calculate L4 TCP/UDP checksum */
487 /* add pseudo header to csum */
488 if (l3_proto
== ETH_P_IP
) {
489 csum_cntr
= eth_calc_ip4_pseudo_hdr_csum(
490 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
,
492 } else if (l3_proto
== ETH_P_IPV6
) {
493 csum_cntr
= eth_calc_ip6_pseudo_hdr_csum(
494 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_base
,
495 csl
, pkt
->l4proto
, &cso
);
500 net_checksum_add_iov(iov
, iov_len
, pkt
->virt_hdr
.csum_start
, csl
, cso
);
502 /* Put the checksum obtained into the packet */
503 csum
= cpu_to_be16(net_checksum_finish_nozero(csum_cntr
));
504 iov_from_buf(iov
, iov_len
, csum_offset
, &csum
, sizeof csum
);
507 #define NET_MAX_FRAG_SG_LIST (64)
509 static size_t net_tx_pkt_fetch_fragment(struct NetTxPkt
*pkt
,
510 int *src_idx
, size_t *src_offset
, size_t src_len
,
511 struct iovec
*dst
, int *dst_idx
)
514 struct iovec
*src
= pkt
->vec
;
516 while (fetched
< src_len
) {
518 /* no more place in fragment iov */
519 if (*dst_idx
== NET_MAX_FRAG_SG_LIST
) {
523 /* no more data in iovec */
524 if (*src_idx
== (pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
)) {
529 dst
[*dst_idx
].iov_base
= src
[*src_idx
].iov_base
+ *src_offset
;
530 dst
[*dst_idx
].iov_len
= MIN(src
[*src_idx
].iov_len
- *src_offset
,
533 *src_offset
+= dst
[*dst_idx
].iov_len
;
534 fetched
+= dst
[*dst_idx
].iov_len
;
536 if (*src_offset
== src
[*src_idx
].iov_len
) {
547 static void net_tx_pkt_sendv(
548 void *opaque
, const struct iovec
*iov
, int iov_cnt
,
549 const struct iovec
*virt_iov
, int virt_iov_cnt
)
551 NetClientState
*nc
= opaque
;
553 if (qemu_get_using_vnet_hdr(nc
->peer
)) {
554 qemu_sendv_packet(nc
, virt_iov
, virt_iov_cnt
);
556 qemu_sendv_packet(nc
, iov
, iov_cnt
);
560 static bool net_tx_pkt_tcp_fragment_init(struct NetTxPkt
*pkt
,
561 struct iovec
*fragment
,
568 struct iovec
*l4
= fragment
+ NET_TX_PKT_PL_START_FRAG
;
569 size_t bytes_read
= 0;
572 if (!pkt
->payload_frags
) {
576 l4
->iov_len
= pkt
->virt_hdr
.hdr_len
- pkt
->hdr_len
;
577 l4
->iov_base
= g_malloc(l4
->iov_len
);
579 *src_idx
= NET_TX_PKT_PL_START_FRAG
;
580 while (pkt
->vec
[*src_idx
].iov_len
< l4
->iov_len
- bytes_read
) {
581 memcpy((char *)l4
->iov_base
+ bytes_read
, pkt
->vec
[*src_idx
].iov_base
,
582 pkt
->vec
[*src_idx
].iov_len
);
584 bytes_read
+= pkt
->vec
[*src_idx
].iov_len
;
587 if (*src_idx
>= pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
) {
588 g_free(l4
->iov_base
);
593 *src_offset
= l4
->iov_len
- bytes_read
;
594 memcpy((char *)l4
->iov_base
+ bytes_read
, pkt
->vec
[*src_idx
].iov_base
,
598 th
->th_flags
&= ~(TH_FIN
| TH_PUSH
);
600 *pl_idx
= NET_TX_PKT_PL_START_FRAG
+ 1;
601 *l4hdr_len
= l4
->iov_len
;
602 *src_len
= pkt
->virt_hdr
.gso_size
;
607 static void net_tx_pkt_tcp_fragment_deinit(struct iovec
*fragment
)
609 g_free(fragment
[NET_TX_PKT_PL_START_FRAG
].iov_base
);
612 static void net_tx_pkt_tcp_fragment_fix(struct NetTxPkt
*pkt
,
613 struct iovec
*fragment
,
617 struct iovec
*l3hdr
= fragment
+ NET_TX_PKT_L3HDR_FRAG
;
618 struct iovec
*l4hdr
= fragment
+ NET_TX_PKT_PL_START_FRAG
;
619 struct ip_header
*ip
= l3hdr
->iov_base
;
620 struct ip6_header
*ip6
= l3hdr
->iov_base
;
621 size_t len
= l3hdr
->iov_len
+ l4hdr
->iov_len
+ fragment_len
;
624 case VIRTIO_NET_HDR_GSO_TCPV4
:
625 ip
->ip_len
= cpu_to_be16(len
);
626 eth_fix_ip4_checksum(l3hdr
->iov_base
, l3hdr
->iov_len
);
629 case VIRTIO_NET_HDR_GSO_TCPV6
:
630 len
-= sizeof(struct ip6_header
);
631 ip6
->ip6_ctlun
.ip6_un1
.ip6_un1_plen
= cpu_to_be16(len
);
636 static void net_tx_pkt_tcp_fragment_advance(struct NetTxPkt
*pkt
,
637 struct iovec
*fragment
,
641 struct iovec
*l3hdr
= fragment
+ NET_TX_PKT_L3HDR_FRAG
;
642 struct iovec
*l4hdr
= fragment
+ NET_TX_PKT_PL_START_FRAG
;
643 struct ip_header
*ip
= l3hdr
->iov_base
;
644 struct tcp_hdr
*th
= l4hdr
->iov_base
;
646 if (gso_type
== VIRTIO_NET_HDR_GSO_TCPV4
) {
647 ip
->ip_id
= cpu_to_be16(be16_to_cpu(ip
->ip_id
) + 1);
650 th
->th_seq
= cpu_to_be32(be32_to_cpu(th
->th_seq
) + fragment_len
);
651 th
->th_flags
&= ~TH_CWR
;
654 static void net_tx_pkt_udp_fragment_init(struct NetTxPkt
*pkt
,
657 int *src_idx
, size_t *src_offset
,
660 *pl_idx
= NET_TX_PKT_PL_START_FRAG
;
662 *src_idx
= NET_TX_PKT_PL_START_FRAG
;
664 *src_len
= IP_FRAG_ALIGN_SIZE(pkt
->virt_hdr
.gso_size
);
667 static void net_tx_pkt_udp_fragment_fix(struct NetTxPkt
*pkt
,
668 struct iovec
*fragment
,
669 size_t fragment_offset
,
672 bool more_frags
= fragment_offset
+ fragment_len
< pkt
->payload_len
;
674 struct iovec
*l3hdr
= fragment
+ NET_TX_PKT_L3HDR_FRAG
;
675 struct ip_header
*ip
= l3hdr
->iov_base
;
676 uint16_t frag_off_units
= fragment_offset
/ IP_FRAG_UNIT_SIZE
;
679 assert(fragment_offset
% IP_FRAG_UNIT_SIZE
== 0);
680 assert((frag_off_units
& ~IP_OFFMASK
) == 0);
682 orig_flags
= be16_to_cpu(ip
->ip_off
) & ~(IP_OFFMASK
| IP_MF
);
683 new_ip_off
= frag_off_units
| orig_flags
| (more_frags
? IP_MF
: 0);
684 ip
->ip_off
= cpu_to_be16(new_ip_off
);
685 ip
->ip_len
= cpu_to_be16(l3hdr
->iov_len
+ fragment_len
);
687 eth_fix_ip4_checksum(l3hdr
->iov_base
, l3hdr
->iov_len
);
690 static bool net_tx_pkt_do_sw_fragmentation(struct NetTxPkt
*pkt
,
691 NetTxPktCallback callback
,
694 uint8_t gso_type
= pkt
->virt_hdr
.gso_type
& ~VIRTIO_NET_HDR_GSO_ECN
;
696 struct iovec fragment
[NET_MAX_FRAG_SG_LIST
];
701 int src_idx
, dst_idx
, pl_idx
;
703 size_t fragment_offset
= 0;
704 struct virtio_net_hdr virt_hdr
= {
705 .flags
= pkt
->virt_hdr
.flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
?
706 VIRTIO_NET_HDR_F_DATA_VALID
: 0
710 fragment
[NET_TX_PKT_VHDR_FRAG
].iov_base
= &virt_hdr
;
711 fragment
[NET_TX_PKT_VHDR_FRAG
].iov_len
= sizeof(virt_hdr
);
712 fragment
[NET_TX_PKT_L2HDR_FRAG
] = pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
];
713 fragment
[NET_TX_PKT_L3HDR_FRAG
] = pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
];
716 case VIRTIO_NET_HDR_GSO_TCPV4
:
717 case VIRTIO_NET_HDR_GSO_TCPV6
:
718 if (!net_tx_pkt_tcp_fragment_init(pkt
, fragment
, &pl_idx
, &l4hdr_len
,
719 &src_idx
, &src_offset
, &src_len
)) {
724 case VIRTIO_NET_HDR_GSO_UDP
:
725 net_tx_pkt_do_sw_csum(pkt
, &pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
],
726 pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
- 1,
728 net_tx_pkt_udp_fragment_init(pkt
, &pl_idx
, &l4hdr_len
,
729 &src_idx
, &src_offset
, &src_len
);
736 /* Put as much data as possible and send */
739 fragment_len
= net_tx_pkt_fetch_fragment(pkt
,
740 &src_idx
, &src_offset
, src_len
, fragment
, &dst_idx
);
746 case VIRTIO_NET_HDR_GSO_TCPV4
:
747 case VIRTIO_NET_HDR_GSO_TCPV6
:
748 net_tx_pkt_tcp_fragment_fix(pkt
, fragment
, fragment_len
, gso_type
);
749 net_tx_pkt_do_sw_csum(pkt
, fragment
+ NET_TX_PKT_L2HDR_FRAG
,
750 dst_idx
- NET_TX_PKT_L2HDR_FRAG
,
751 l4hdr_len
+ fragment_len
);
754 case VIRTIO_NET_HDR_GSO_UDP
:
755 net_tx_pkt_udp_fragment_fix(pkt
, fragment
, fragment_offset
,
761 fragment
+ NET_TX_PKT_L2HDR_FRAG
, dst_idx
- NET_TX_PKT_L2HDR_FRAG
,
762 fragment
+ NET_TX_PKT_VHDR_FRAG
, dst_idx
- NET_TX_PKT_VHDR_FRAG
);
764 if (gso_type
== VIRTIO_NET_HDR_GSO_TCPV4
||
765 gso_type
== VIRTIO_NET_HDR_GSO_TCPV6
) {
766 net_tx_pkt_tcp_fragment_advance(pkt
, fragment
, fragment_len
,
770 fragment_offset
+= fragment_len
;
773 if (gso_type
== VIRTIO_NET_HDR_GSO_TCPV4
||
774 gso_type
== VIRTIO_NET_HDR_GSO_TCPV6
) {
775 net_tx_pkt_tcp_fragment_deinit(fragment
);
781 bool net_tx_pkt_send(struct NetTxPkt
*pkt
, NetClientState
*nc
)
783 bool offload
= qemu_get_using_vnet_hdr(nc
->peer
);
784 return net_tx_pkt_send_custom(pkt
, offload
, net_tx_pkt_sendv
, nc
);
787 bool net_tx_pkt_send_custom(struct NetTxPkt
*pkt
, bool offload
,
788 NetTxPktCallback callback
, void *context
)
793 * Since underlying infrastructure does not support IP datagrams longer
794 * than 64K we should drop such packets and don't even try to send
796 if (VIRTIO_NET_HDR_GSO_NONE
!= pkt
->virt_hdr
.gso_type
) {
797 if (pkt
->payload_len
>
798 ETH_MAX_IP_DGRAM_LEN
-
799 pkt
->vec
[NET_TX_PKT_L3HDR_FRAG
].iov_len
) {
804 if (offload
|| pkt
->virt_hdr
.gso_type
== VIRTIO_NET_HDR_GSO_NONE
) {
805 if (!offload
&& pkt
->virt_hdr
.flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) {
806 net_tx_pkt_do_sw_csum(pkt
, &pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
],
807 pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
- 1,
811 net_tx_pkt_fix_ip6_payload_len(pkt
);
812 callback(context
, pkt
->vec
+ NET_TX_PKT_L2HDR_FRAG
,
813 pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
- NET_TX_PKT_L2HDR_FRAG
,
814 pkt
->vec
+ NET_TX_PKT_VHDR_FRAG
,
815 pkt
->payload_frags
+ NET_TX_PKT_PL_START_FRAG
- NET_TX_PKT_VHDR_FRAG
);
819 return net_tx_pkt_do_sw_fragmentation(pkt
, callback
, context
);
822 void net_tx_pkt_fix_ip6_payload_len(struct NetTxPkt
*pkt
)
824 struct iovec
*l2
= &pkt
->vec
[NET_TX_PKT_L2HDR_FRAG
];
825 if (eth_get_l3_proto(l2
, 1, l2
->iov_len
) == ETH_P_IPV6
) {
826 struct ip6_header
*ip6
= (struct ip6_header
*) pkt
->l3_hdr
;
828 * TODO: if qemu would support >64K packets - add jumbo option check
829 * something like that:
830 * 'if (ip6->ip6_plen == 0 && !has_jumbo_option(ip6)) {'
832 if (ip6
->ip6_plen
== 0) {
833 if (pkt
->payload_len
<= ETH_MAX_IP_DGRAM_LEN
) {
834 ip6
->ip6_plen
= htons(pkt
->payload_len
);
837 * TODO: if qemu would support >64K packets
838 * add jumbo option for packets greater then 65,535 bytes