Now that we can rely on do_not_pad being correct for all
NetClientInfo structs, we can pad short packets in the
qemu_send_packet() and qemu_sendv_packet() family of functions.
If the callsite is already padding, then this will have no effect,
but callsites like the socket and dgram backends will now correctly
add padding. This fixes the bug where when two QEMU instances are
connected via one of those backends a short ARP packet transmitted by
one is not correctly padded by the other and gets dropped.
Note that if we pad a packet, our return value on success will
be the size of the padded packet, not the original. This is OK
because this function (like the NetQueueDeliverFunc function type
documented in include/net/queue.h and which we will eventually
end up calling and returning the return value of) returns
>0 - success
0 - queue packet for future redelivery
<0 - failure (discard packet)
and doesn't guarantee to return exactly the size of the packet
sent. None of the callers try to use the return value as an
exact size.
Cc: [email protected]
Resolves: https://gitlab.com/qemu-project/qemu/-/work_items/2362
Signed-off-by: Peter Maydell <[email protected]>
---
include/net/eth.h | 22 ++++++++++++++++++++++
net/eth.c | 18 ++++++++++++++++++
net/net.c | 22 ++++++++++++++++++++++
3 files changed, 62 insertions(+)
diff --git a/include/net/eth.h b/include/net/eth.h
index 46dc9ed5acd..042b2fc42db 100644
--- a/include/net/eth.h
+++ b/include/net/eth.h
@@ -437,4 +437,26 @@ eth_parse_ipv6_hdr(const struct iovec *pkt, int pkt_frags,
bool eth_pad_short_frame(uint8_t *padded_pkt, size_t *padded_buflen,
const void *pkt, size_t pkt_size);
+/**
+ * eth_pad_short_frame_iov - pad a short frame, iovec version
+ *
+ * This is equivalent to eth_pad_short_frame(), except that it works
+ * on a packet stored in a struct iovec.
+ *
+ * If the Ethernet frame size is shorter than 60 bytes, it will be padded to
+ * 60 bytes at the address @padded_pkt (and the caller will need to handle
+ * it as a not-in-an-iovec packet).
+ *
+ * @padded_pkt: buffer address to hold the padded frame
+ * @padded_buflen: pointer holding length of @padded_pkt. If the frame is
+ * padded, the length will be updated to the padded one.
+ * @iov: iovec holding the original Ethernet frame
+ * @iovcnt: number of elements in @iov
+ * @pkt_size: size of the original Ethernet frame (i.e. iov_size(iov, iovcnt))
+ * @return true if the frame is padded, otherwise false
+ */
+bool eth_pad_short_frame_iov(uint8_t *padded_pkt, size_t *padded_buflen,
+ const struct iovec *iov, int iovcnt,
+ size_t pkt_size);
+
#endif
diff --git a/net/eth.c b/net/eth.c
index 12ec316e240..14006222d68 100644
--- a/net/eth.c
+++ b/net/eth.c
@@ -536,3 +536,21 @@ bool eth_pad_short_frame(uint8_t *padded_pkt, size_t
*padded_buflen,
return true;
}
+
+bool eth_pad_short_frame_iov(uint8_t *padded_pkt, size_t *padded_buflen,
+ const struct iovec *iov, int iovcnt,
+ size_t pkt_size)
+{
+ assert(padded_buflen && *padded_buflen >= ETH_ZLEN);
+
+ if (pkt_size >= ETH_ZLEN) {
+ return false;
+ }
+
+ /* pad to minimum Ethernet frame length */
+ iov_to_buf(iov, iovcnt, 0, padded_pkt, pkt_size);
+ memset(&padded_pkt[pkt_size], 0, ETH_ZLEN - pkt_size);
+ *padded_buflen = ETH_ZLEN;
+
+ return true;
+}
diff --git a/net/net.c b/net/net.c
index 1042a9d3a8e..408871d3c21 100644
--- a/net/net.c
+++ b/net/net.c
@@ -735,6 +735,8 @@ static ssize_t
qemu_send_packet_async_with_flags(NetClientState *sender,
{
NetQueue *queue;
int ret;
+ uint8_t min_pkt[ETH_ZLEN];
+ size_t min_pktsz = sizeof(min_pkt);
#ifdef DEBUG_NET
printf("qemu_send_packet_async:\n");
@@ -745,6 +747,13 @@ static ssize_t
qemu_send_packet_async_with_flags(NetClientState *sender,
return size;
}
+ if (net_peer_needs_padding(sender)) {
+ if (eth_pad_short_frame(min_pkt, &min_pktsz, buf, size)) {
+ buf = min_pkt;
+ size = min_pktsz;
+ }
+ }
+
/* Let filters handle the packet first */
ret = filter_receive(sender, NET_FILTER_DIRECTION_TX,
sender, flags, buf, size, sent_cb);
@@ -899,6 +908,19 @@ ssize_t qemu_sendv_packet_async(NetClientState *sender,
return size;
}
+ if (net_peer_needs_padding(sender)) {
+ uint8_t min_pkt[ETH_ZLEN];
+ size_t min_pktsz = sizeof(min_pkt);
+
+ /*
+ * If we pad the packet, we get back a simple buffer, so handle
+ * it by sending it to the non-iov qemu_send_packet function
+ */
+ if (eth_pad_short_frame_iov(min_pkt, &min_pktsz, iov, iovcnt, size)) {
+ return qemu_send_packet_async(sender, min_pkt, min_pktsz, sent_cb);
+ }
+ }
+
/* Let filters handle the packet first */
ret = filter_receive_iov(sender, NET_FILTER_DIRECTION_TX, sender,
QEMU_NET_PACKET_FLAG_NONE, iov, iovcnt, sent_cb);
--
2.43.0
