[PATCH v3 00/13] net: Pad short frames for network backends

[PATCH v3 00/13] net: Pad short frames for network backends

[Bin Meng]

The minimum Ethernet frame length is 60 bytes. For short frames with
smaller length like ARP packets (only 42 bytes), on a real world NIC
it can choose either padding its length to the minimum required 60
bytes, or sending it out directly to the wire. Such behavior can be
hardcoded or controled by a register bit. Similarly on the receive
path, NICs can choose either dropping such short frames directly or
handing them over to software to handle.

On the other hand, for the network backends like SLiRP/TAP, they
don't expose a way to control the short frame behavior. As of today
they just send/receive data from/to the other end connected to them,
which means any sized packet is acceptable. So they can send and
receive short frames without any problem. It is observed that ARP
packets sent from SLiRP/TAP are 42 bytes, and SLiRP/TAP just send
these ARP packets to the other end which might be a NIC model that
does not allow short frames to pass through.

To provide better compatibility, for packets sent from QEMU network
backends like SLiRP/TAP, we change to pad short frames before sending
it out to the other end, if the other end does not forbid it via the
nc->do_not_pad flag. This ensures a backend as an Ethernet sender
does not violate the spec. But with this change, the behavior of
dropping short frames from SLiRP/TAP interfaces in the NIC model
cannot be emulated because it always receives a packet that is spec
complaint. The capability of sending short frames from NIC models is
still supported and short frames can still pass through SLiRP/TAP.

This series should be able to fix the issue as reported with some
NIC models before, that ARP requests get dropped, preventing the
guest from becoming visible on the network. It was workarounded in
these NIC models on the receive path, that when a short frame is
received, it is padded up to 60 bytes.

Changes in v3:
- use 'without' instead of 'sans'
- add a helper to pad short frames
- add a comment to 'do_not_pad'
- use the pad_short_frame() helper for slirp
- use the pad_short_frame() helper for tap

Bin Meng (13):
  net: eth: Add a helper to pad a short ethernet frame
  net: Add a 'do_not_pad" to NetClientState
  net: slirp: Pad short frames to minimum size before send
  net: tap: Pad short frames to minimum size before send
  hw/net: virtio-net: Initialize nc->do_not_pad to true
  hw/net: e1000: Remove the logic of padding short frames in the receive
    path
  hw/net: vmxnet3: Remove the logic of padding short frames in the
    receive path
  hw/net: i82596: Remove the logic of padding short frames in the
    receive path
  hw/net: ne2000: Remove the logic of padding short frames in the
    receive path
  hw/net: pcnet: Remove the logic of padding short frames in the receive
    path
  hw/net: rtl8139: Remove the logic of padding short frames in the
    receive path
  hw/net: sungem: Remove the logic of padding short frames in the
    receive path
  hw/net: sunhme: Remove the logic of padding short frames in the
    receive path

 hw/net/e1000.c      | 11 +----------
 hw/net/i82596.c     | 18 ------------------
 hw/net/ne2000.c     | 12 ------------
 hw/net/pcnet.c      |  9 ---------
 hw/net/rtl8139.c    | 12 ------------
 hw/net/sungem.c     | 14 --------------
 hw/net/sunhme.c     | 11 -----------
 hw/net/virtio-net.c |  4 ++++
 hw/net/vmxnet3.c    | 10 ----------
 include/net/eth.h   | 25 +++++++++++++++++++++++++
 include/net/net.h   |  1 +
 net/slirp.c         |  9 +++++++++
 net/tap-win32.c     |  9 +++++++++
 net/tap.c           |  9 +++++++++
 14 files changed, 58 insertions(+), 96 deletions(-)

-- 
2.17.1

[PATCH v3 01/13] net: eth: Add a helper to pad a short ethernet frame

[Bin Meng]

Add a helper to pad a short ethernet frame to the minimum required
length, which can be used by backend codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>

---

Changes in v3:
- use 'without' instead of 'sans'
- add a helper to pad short frames

 include/net/eth.h | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/include/net/eth.h b/include/net/eth.h
index 0671be6916..bc064f8e52 100644
--- a/include/net/eth.h
+++ b/include/net/eth.h
@@ -31,6 +31,31 @@
 
 #define ETH_ALEN 6
 #define ETH_HLEN 14
+#define ETH_ZLEN 60     /* Min. octets in frame without FCS */
+
+/**
+ * pad_short_frame - pad a short frame to the minimum ethernet frame length
+ *
+ * If the ethernet frame size is shorter than 60 bytes, it will be padded to
+ * 60 bytes at the address @min_pkt.
+ *
+ * @min_pkt: buffer address to hold the padded frame
+ * @pkt: address to hold the original ethernet frame
+ * @size: size of the original ethernet frame
+ * @return true if the frame is padded, otherwise false
+ */
+static inline bool pad_short_frame(uint8_t *min_pkt, const uint8_t *pkt,
+                                   int size)
+{
+    if (size < ETH_ZLEN) {
+        /* pad to minimum ethernet frame length */
+        memcpy(min_pkt, pkt, size);
+        memset(&min_pkt[size], 0, ETH_ZLEN - size);
+        return true;
+    }
+
+    return false;
+}
 
 struct eth_header {
     uint8_t  h_dest[ETH_ALEN];   /* destination eth addr */
-- 
2.17.1

[PATCH v3 02/13] net: Add a 'do_not_pad" to NetClientState

[Bin Meng]

This adds a flag in NetClientState, so that a net client can tell
its peer that the packets do not need to be padded to the minimum
size of an Ethernet frame (60 bytes) before sending to it.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

---

Changes in v3:
- add a comment to 'do_not_pad'

 include/net/net.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/net/net.h b/include/net/net.h
index 919facaad2..f944731c18 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -100,6 +100,7 @@ struct NetClientState {
     int vring_enable;
     int vnet_hdr_len;
     bool is_netdev;
+    bool do_not_pad; /* do not pad to the minimum ethernet frame length */
     QTAILQ_HEAD(, NetFilterState) filters;
 };
 
-- 
2.17.1

[PATCH v3 03/13] net: slirp: Pad short frames to minimum size before send

[Bin Meng]

The minimum Ethernet frame length is 60 bytes. For short frames with
smaller length like ARP packets (only 42 bytes), on a real world NIC
it can choose either padding its length to the minimum required 60
bytes, or sending it out directly to the wire. Such behavior can be
hardcoded or controled by a register bit. Similarly on the receive
path, NICs can choose either dropping such short frames directly or
handing them over to software to handle.

On the other hand, for the network backends like SLiRP/TAP, they
don't expose a way to control the short frame behavior. As of today
they just send/receive data from/to the other end connected to them,
which means any sized packet is acceptable. So they can send and
receive short frames without any problem. It is observed that ARP
packets sent from SLiRP/TAP are 42 bytes, and SLiRP/TAP just send
these ARP packets to the other end which might be a NIC model that
does not allow short frames to pass through.

To provide better compatibility, for packets sent from QEMU network
backends like SLiRP/TAP, we change to pad short frames before sending
it out to the other end, if the other end does not forbid it via the
nc->do_not_pad flag. This ensures a backend as an Ethernet sender
does not violate the spec. But with this change, the behavior of
dropping short frames from SLiRP/TAP interfaces in the NIC model
cannot be emulated because it always receives a packet that is spec
complaint. The capability of sending short frames from NIC models is
still supported and short frames can still pass through SLiRP/TAP.

This commit should be able to fix the issue as reported with some
NIC models before, that ARP requests get dropped, preventing the
guest from becoming visible on the network. It was workarounded in
these NIC models on the receive path, that when a short frame is
received, it is padded up to 60 bytes.

The following 2 commits seem to be the one to workaround this issue
in e1000 and vmxenet3 before, and should probably be reverted.

  commit 78aeb23eded2 ("e1000: Pad short frames to minimum size (60 bytes)")
  commit 40a87c6c9b11 ("vmxnet3: Pad short frames to minimum size (60 bytes)")

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>

---

Changes in v3:
- use the pad_short_frame() helper for slirp

 net/slirp.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/net/slirp.c b/net/slirp.c
index be914c0be0..62a54d45dc 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -31,6 +31,7 @@
 #include <pwd.h>
 #include <sys/wait.h>
 #endif
+#include "net/eth.h"
 #include "net/net.h"
 #include "clients.h"
 #include "hub.h"
@@ -115,6 +116,14 @@ static ssize_t net_slirp_send_packet(const void *pkt, size_t pkt_len,
                                      void *opaque)
 {
     SlirpState *s = opaque;
+    uint8_t min_pkt[ETH_ZLEN];
+
+    if (!s->nc.peer->do_not_pad) {
+        if (pad_short_frame(min_pkt, pkt, pkt_len)) {
+            pkt = min_pkt;
+            pkt_len = ETH_ZLEN;
+        }
+    }
 
     return qemu_send_packet(&s->nc, pkt, pkt_len);
 }
-- 
2.17.1

[PATCH v3 04/13] net: tap: Pad short frames to minimum size before send

[Bin Meng]

Do the same for tap backend as what we did for slirp.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>

---

Changes in v3:
- use the pad_short_frame() helper for tap

 net/tap-win32.c | 9 +++++++++
 net/tap.c       | 9 +++++++++
 2 files changed, 18 insertions(+)

diff --git a/net/tap-win32.c b/net/tap-win32.c
index 2b5dcda36e..e044a5ca35 100644
--- a/net/tap-win32.c
+++ b/net/tap-win32.c
@@ -31,6 +31,7 @@
 
 #include "qemu-common.h"
 #include "clients.h"            /* net_init_tap */
+#include "net/eth.h"
 #include "net/net.h"
 #include "net/tap.h"            /* tap_has_ufo, ... */
 #include "qemu/error-report.h"
@@ -688,9 +689,17 @@ static void tap_win32_send(void *opaque)
     uint8_t *buf;
     int max_size = 4096;
     int size;
+    uint8_t min_pkt[ETH_ZLEN];
 
     size = tap_win32_read(s->handle, &buf, max_size);
     if (size > 0) {
+        if (!s->nc.peer->do_not_pad) {
+            if (pad_short_frame(min_pkt, buf, size)) {
+                buf = min_pkt;
+                size = ETH_ZLEN;
+            }
+        }
+
         qemu_send_packet(&s->nc, buf, size);
         tap_win32_free_buffer(s->handle, buf);
     }
diff --git a/net/tap.c b/net/tap.c
index b7512853f4..aa69cf1c73 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -32,6 +32,7 @@
 #include <sys/socket.h>
 #include <net/if.h>
 
+#include "net/eth.h"
 #include "net/net.h"
 #include "clients.h"
 #include "monitor/monitor.h"
@@ -189,6 +190,7 @@ static void tap_send(void *opaque)
 
     while (true) {
         uint8_t *buf = s->buf;
+        uint8_t min_pkt[ETH_ZLEN];
 
         size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
         if (size <= 0) {
@@ -200,6 +202,13 @@ static void tap_send(void *opaque)
             size -= s->host_vnet_hdr_len;
         }
 
+        if (!s->nc.peer->do_not_pad) {
+            if (pad_short_frame(min_pkt, buf, size)) {
+                buf = min_pkt;
+                size = ETH_ZLEN;
+            }
+        }
+
         size = qemu_send_packet_async(&s->nc, buf, size, tap_send_completed);
         if (size == 0) {
             tap_read_poll(s, false);
-- 
2.17.1

[PATCH v3 05/13] hw/net: virtio-net: Initialize nc->do_not_pad to true

[Bin Meng]

For virtio-net, there is no need to pad the Ethernet frame size to
60 bytes before sending to it.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/virtio-net.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index 96a3cc8357..66b9ff4511 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -3314,6 +3314,10 @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
                               object_get_typename(OBJECT(dev)), dev->id, n);
     }
 
+    for (i = 0; i < n->max_queues; i++) {
+        n->nic->ncs[i].do_not_pad = true;
+    }
+
     peer_test_vnet_hdr(n);
     if (peer_has_vnet_hdr(n)) {
         for (i = 0; i < n->max_queues; i++) {
-- 
2.17.1

[PATCH v3 06/13] hw/net: e1000: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

This actually reverts commit 78aeb23eded2d0b765bf9145c71f80025b568acd.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/e1000.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/hw/net/e1000.c b/hw/net/e1000.c
index d8da2f6528..a53ba9052b 100644
--- a/hw/net/e1000.c
+++ b/hw/net/e1000.c
@@ -882,7 +882,6 @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt)
     uint16_t vlan_special = 0;
     uint8_t vlan_status = 0;
     uint8_t min_buf[MIN_BUF_SIZE];
-    struct iovec min_iov;
     uint8_t *filter_buf = iov->iov_base;
     size_t size = iov_size(iov, iovcnt);
     size_t iov_ofs = 0;
@@ -898,15 +897,7 @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt)
         return 0;
     }
 
-    /* Pad to minimum Ethernet frame length */
-    if (size < sizeof(min_buf)) {
-        iov_to_buf(iov, iovcnt, 0, min_buf, size);
-        memset(&min_buf[size], 0, sizeof(min_buf) - size);
-        min_iov.iov_base = filter_buf = min_buf;
-        min_iov.iov_len = size = sizeof(min_buf);
-        iovcnt = 1;
-        iov = &min_iov;
-    } else if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) {
+    if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) {
         /* This is very unlikely, but may happen. */
         iov_to_buf(iov, iovcnt, 0, min_buf, MAXIMUM_ETHERNET_HDR_LEN);
         filter_buf = min_buf;
-- 
2.17.1

[PATCH v3 07/13] hw/net: vmxnet3: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

This actually reverts commit 40a87c6c9b11ef9c14e0301f76abf0eb2582f08e.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/vmxnet3.c | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c
index eff299f629..d993cce097 100644
--- a/hw/net/vmxnet3.c
+++ b/hw/net/vmxnet3.c
@@ -39,7 +39,6 @@
 
 #define PCI_DEVICE_ID_VMWARE_VMXNET3_REVISION 0x1
 #define VMXNET3_MSIX_BAR_SIZE 0x2000
-#define MIN_BUF_SIZE 60
 
 /* Compatibility flags for migration */
 #define VMXNET3_COMPAT_FLAG_OLD_MSI_OFFSETS_BIT 0
@@ -1951,7 +1950,6 @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size)
 {
     VMXNET3State *s = qemu_get_nic_opaque(nc);
     size_t bytes_indicated;
-    uint8_t min_buf[MIN_BUF_SIZE];
 
     if (!vmxnet3_can_receive(nc)) {
         VMW_PKPRN("Cannot receive now");
@@ -1964,14 +1962,6 @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size)
         size -= sizeof(struct virtio_net_hdr);
     }
 
-    /* Pad to minimum Ethernet frame length */
-    if (size < sizeof(min_buf)) {
-        memcpy(min_buf, buf, size);
-        memset(&min_buf[size], 0, sizeof(min_buf) - size);
-        buf = min_buf;
-        size = sizeof(min_buf);
-    }
-
     net_rx_pkt_set_packet_type(s->rx_pkt,
         get_eth_packet_type(PKT_GET_ETH_HDR(buf)));
 
-- 
2.17.1

[PATCH v3 08/13] hw/net: i82596: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/i82596.c | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/hw/net/i82596.c b/hw/net/i82596.c
index 055c3a1470..1eca2e2d81 100644
--- a/hw/net/i82596.c
+++ b/hw/net/i82596.c
@@ -73,10 +73,6 @@ enum commands {
 #define I596_EOF        0x8000
 #define SIZE_MASK       0x3fff
 
-#define ETHER_TYPE_LEN 2
-#define VLAN_TCI_LEN 2
-#define VLAN_HLEN (ETHER_TYPE_LEN + VLAN_TCI_LEN)
-
 /* various flags in the chip config registers */
 #define I596_PREFETCH   (s->config[0] & 0x80)
 #define I596_PROMISC    (s->config[8] & 0x01)
@@ -489,8 +485,6 @@ bool i82596_can_receive(NetClientState *nc)
     return true;
 }
 
-#define MIN_BUF_SIZE 60
-
 ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz)
 {
     I82596State *s = qemu_get_nic_opaque(nc);
@@ -501,7 +495,6 @@ ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz)
     size_t bufsz = sz; /* length of data in buf */
     uint32_t crc;
     uint8_t *crc_ptr;
-    uint8_t buf1[MIN_BUF_SIZE + VLAN_HLEN];
     static const uint8_t broadcast_macaddr[6] = {
                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 
@@ -584,17 +577,6 @@ ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz)
         }
     }
 
-    /* if too small buffer, then expand it */
-    if (len < MIN_BUF_SIZE + VLAN_HLEN) {
-        memcpy(buf1, buf, len);
-        memset(buf1 + len, 0, MIN_BUF_SIZE + VLAN_HLEN - len);
-        buf = buf1;
-        if (len < MIN_BUF_SIZE) {
-            len = MIN_BUF_SIZE;
-        }
-        bufsz = len;
-    }
-
     /* Calculate the ethernet checksum (4 bytes) */
     len += 4;
     crc = cpu_to_be32(crc32(~0, buf, sz));
-- 
2.17.1

[PATCH v3 09/13] hw/net: ne2000: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/ne2000.c | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/hw/net/ne2000.c b/hw/net/ne2000.c
index 6c17ee1ae2..b0a120ece6 100644
--- a/hw/net/ne2000.c
+++ b/hw/net/ne2000.c
@@ -167,15 +167,12 @@ static int ne2000_buffer_full(NE2000State *s)
     return 0;
 }
 
-#define MIN_BUF_SIZE 60
-
 ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_)
 {
     NE2000State *s = qemu_get_nic_opaque(nc);
     size_t size = size_;
     uint8_t *p;
     unsigned int total_len, next, avail, len, index, mcast_idx;
-    uint8_t buf1[60];
     static const uint8_t broadcast_macaddr[6] =
         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 
@@ -213,15 +210,6 @@ ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_)
         }
     }
 
-
-    /* if too small buffer, then expand it */
-    if (size < MIN_BUF_SIZE) {
-        memcpy(buf1, buf, size);
-        memset(buf1 + size, 0, MIN_BUF_SIZE - size);
-        buf = buf1;
-        size = MIN_BUF_SIZE;
-    }
-
     index = s->curpag << 8;
     if (index >= NE2000_PMEM_END) {
         index = s->start;
-- 
2.17.1

[PATCH v3 10/13] hw/net: pcnet: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/pcnet.c | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/hw/net/pcnet.c b/hw/net/pcnet.c
index f3f18d8598..16330335cd 100644
--- a/hw/net/pcnet.c
+++ b/hw/net/pcnet.c
@@ -987,7 +987,6 @@ ssize_t pcnet_receive(NetClientState *nc, const uint8_t *buf, size_t size_)
 {
     PCNetState *s = qemu_get_nic_opaque(nc);
     int is_padr = 0, is_bcast = 0, is_ladr = 0;
-    uint8_t buf1[60];
     int remaining;
     int crc_err = 0;
     size_t size = size_;
@@ -1000,14 +999,6 @@ ssize_t pcnet_receive(NetClientState *nc, const uint8_t *buf, size_t size_)
     printf("pcnet_receive size=%zu\n", size);
 #endif
 
-    /* if too small buffer, then expand it */
-    if (size < MIN_BUF_SIZE) {
-        memcpy(buf1, buf, size);
-        memset(buf1 + size, 0, MIN_BUF_SIZE - size);
-        buf = buf1;
-        size = MIN_BUF_SIZE;
-    }
-
     if (CSR_PROM(s)
         || (is_padr=padr_match(s, buf, size))
         || (is_bcast=padr_bcast(s, buf, size))
-- 
2.17.1

[PATCH v3 11/13] hw/net: rtl8139: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/rtl8139.c | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c
index 4675ac878e..cbfe29a286 100644
--- a/hw/net/rtl8139.c
+++ b/hw/net/rtl8139.c
@@ -827,7 +827,6 @@ static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t
 
     uint32_t packet_header = 0;
 
-    uint8_t buf1[MIN_BUF_SIZE + VLAN_HLEN];
     static const uint8_t broadcast_macaddr[6] =
         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 
@@ -939,17 +938,6 @@ static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t
         }
     }
 
-    /* if too small buffer, then expand it
-     * Include some tailroom in case a vlan tag is later removed. */
-    if (size < MIN_BUF_SIZE + VLAN_HLEN) {
-        memcpy(buf1, buf, size);
-        memset(buf1 + size, 0, MIN_BUF_SIZE + VLAN_HLEN - size);
-        buf = buf1;
-        if (size < MIN_BUF_SIZE) {
-            size = MIN_BUF_SIZE;
-        }
-    }
-
     if (rtl8139_cp_receiver_enabled(s))
     {
         if (!rtl8139_cp_rx_valid(s)) {
-- 
2.17.1

[PATCH v3 12/13] hw/net: sungem: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---

(no changes since v1)

 hw/net/sungem.c | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/hw/net/sungem.c b/hw/net/sungem.c
index 33c3722df6..3fa83168db 100644
--- a/hw/net/sungem.c
+++ b/hw/net/sungem.c
@@ -550,7 +550,6 @@ static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf,
     PCIDevice *d = PCI_DEVICE(s);
     uint32_t mac_crc, done, kick, max_fsize;
     uint32_t fcs_size, ints, rxdma_cfg, rxmac_cfg, csum, coff;
-    uint8_t smallbuf[60];
     struct gem_rxd desc;
     uint64_t dbase, baddr;
     unsigned int rx_cond;
@@ -584,19 +583,6 @@ static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf,
         return size;
     }
 
-    /* We don't drop too small frames since we get them in qemu, we pad
-     * them instead. We should probably use the min frame size register
-     * but I don't want to use a variable size staging buffer and I
-     * know both MacOS and Linux use the default 64 anyway. We use 60
-     * here to account for the non-existent FCS.
-     */
-    if (size < 60) {
-        memcpy(smallbuf, buf, size);
-        memset(&smallbuf[size], 0, 60 - size);
-        buf = smallbuf;
-        size = 60;
-    }
-
     /* Get MAC crc */
     mac_crc = net_crc32_le(buf, ETH_ALEN);
 
-- 
2.17.1

[PATCH v3 13/13] hw/net: sunhme: Remove the logic of padding short frames in the receive path

[Bin Meng]

Now that we have implemented unified short frames padding in the
QEMU networking codes, remove the same logic in the NIC codes.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>

---

(no changes since v1)

 hw/net/sunhme.c | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c
index fc34905f87..6971796e57 100644
--- a/hw/net/sunhme.c
+++ b/hw/net/sunhme.c
@@ -714,8 +714,6 @@ static inline void sunhme_set_rx_ring_nr(SunHMEState *s, int i)
     s->erxregs[HME_ERXI_RING >> 2] = ring;
 }
 
-#define MIN_BUF_SIZE 60
-
 static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf,
                               size_t size)
 {
@@ -724,7 +722,6 @@ static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf,
     dma_addr_t rb, addr;
     uint32_t intstatus, status, buffer, buffersize, sum;
     uint16_t csum;
-    uint8_t buf1[60];
     int nr, cr, len, rxoffset, csum_offset;
 
     trace_sunhme_rx_incoming(size);
@@ -775,14 +772,6 @@ static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf,
 
     trace_sunhme_rx_filter_accept();
 
-    /* If too small buffer, then expand it */
-    if (size < MIN_BUF_SIZE) {
-        memcpy(buf1, buf, size);
-        memset(buf1 + size, 0, MIN_BUF_SIZE - size);
-        buf = buf1;
-        size = MIN_BUF_SIZE;
-    }
-
     rb = s->erxregs[HME_ERXI_RING >> 2] & HME_ERXI_RING_ADDR;
     nr = sunhme_get_rx_ring_count(s);
     cr = sunhme_get_rx_ring_nr(s);
-- 
2.17.1

Re: [PATCH v3 01/13] net: eth: Add a helper to pad a short ethernet frame

[Philippe Mathieu-Daudé]

On 3/16/21 9:12 AM, Bin Meng wrote:
> Add a helper to pad a short ethernet frame to the minimum required
> length, which can be used by backend codes.
> 
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> 
> ---
> 
> Changes in v3:
> - use 'without' instead of 'sans'
> - add a helper to pad short frames
> 
>  include/net/eth.h | 25 +++++++++++++++++++++++++
>  1 file changed, 25 insertions(+)
> 
> diff --git a/include/net/eth.h b/include/net/eth.h
> index 0671be6916..bc064f8e52 100644
> --- a/include/net/eth.h
> +++ b/include/net/eth.h
> @@ -31,6 +31,31 @@
>  
>  #define ETH_ALEN 6
>  #define ETH_HLEN 14
> +#define ETH_ZLEN 60     /* Min. octets in frame without FCS */
> +
> +/**
> + * pad_short_frame - pad a short frame to the minimum ethernet frame length
> + *
> + * If the ethernet frame size is shorter than 60 bytes, it will be padded to
> + * 60 bytes at the address @min_pkt.
> + *
> + * @min_pkt: buffer address to hold the padded frame
> + * @pkt: address to hold the original ethernet frame
> + * @size: size of the original ethernet frame
> + * @return true if the frame is padded, otherwise false
> + */
> +static inline bool pad_short_frame(uint8_t *min_pkt, const uint8_t *pkt,
> +                                   int size)
> +{
> +    if (size < ETH_ZLEN) {
> +        /* pad to minimum ethernet frame length */
> +        memcpy(min_pkt, pkt, size);
> +        memset(&min_pkt[size], 0, ETH_ZLEN - size);
> +        return true;
> +    }
> +
> +    return false;
> +}

I don't want to be too nitpicky but since I'm Cc'ed...

- 'ethernet' -> 'Ethernet'

- I'm not sure inlining is justified

- The same function is used for 2 different operations,
  . check if padding is required
  . do the padding

- If we provide a function a buffer to fill, we need to check the
  buffer size is big enough to avoid overflow

What about something like:

  bool pad_short_frame(char *padded_pkt, size_t *padded_buflen,
                       const void *pkt, size_t pkt_size);
  {
      assert(padded_buflen && *padded_buflen >= ETH_ZLEN);
      if (src_size >= ETH_ZLEN) {
          return false;
      }
      /* pad to minimum ethernet frame length */
      memcpy(padded_pkt, pkt, pkt_size);
      memset(&padded_pkt[pkt_size], 0, ETH_ZLEN - padded_buflen);
      *padded_buflen = ETH_ZLEN;

      return true;
  }

What do you think?

Re: [PATCH v3 01/13] net: eth: Add a helper to pad a short ethernet frame

[Bin Meng]

On Tue, Mar 16, 2021 at 4:49 PM Philippe Mathieu-Daudé
<philmd@redhat.com> wrote:
>
> On 3/16/21 9:12 AM, Bin Meng wrote:
> > Add a helper to pad a short ethernet frame to the minimum required
> > length, which can be used by backend codes.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> >
> > ---
> >
> > Changes in v3:
> > - use 'without' instead of 'sans'
> > - add a helper to pad short frames
> >
> >  include/net/eth.h | 25 +++++++++++++++++++++++++
> >  1 file changed, 25 insertions(+)
> >
> > diff --git a/include/net/eth.h b/include/net/eth.h
> > index 0671be6916..bc064f8e52 100644
> > --- a/include/net/eth.h
> > +++ b/include/net/eth.h
> > @@ -31,6 +31,31 @@
> >
> >  #define ETH_ALEN 6
> >  #define ETH_HLEN 14
> > +#define ETH_ZLEN 60     /* Min. octets in frame without FCS */
> > +
> > +/**
> > + * pad_short_frame - pad a short frame to the minimum ethernet frame length
> > + *
> > + * If the ethernet frame size is shorter than 60 bytes, it will be padded to
> > + * 60 bytes at the address @min_pkt.
> > + *
> > + * @min_pkt: buffer address to hold the padded frame
> > + * @pkt: address to hold the original ethernet frame
> > + * @size: size of the original ethernet frame
> > + * @return true if the frame is padded, otherwise false
> > + */
> > +static inline bool pad_short_frame(uint8_t *min_pkt, const uint8_t *pkt,
> > +                                   int size)
> > +{
> > +    if (size < ETH_ZLEN) {
> > +        /* pad to minimum ethernet frame length */
> > +        memcpy(min_pkt, pkt, size);
> > +        memset(&min_pkt[size], 0, ETH_ZLEN - size);
> > +        return true;
> > +    }
> > +
> > +    return false;
> > +}
>
> I don't want to be too nitpicky but since I'm Cc'ed...
>
> - 'ethernet' -> 'Ethernet'
>
> - I'm not sure inlining is justified
>
> - The same function is used for 2 different operations,
>   . check if padding is required
>   . do the padding
>
> - If we provide a function a buffer to fill, we need to check the
>   buffer size is big enough to avoid overflow
>
> What about something like:
>
>   bool pad_short_frame(char *padded_pkt, size_t *padded_buflen,
>                        const void *pkt, size_t pkt_size);
>   {
>       assert(padded_buflen && *padded_buflen >= ETH_ZLEN);
>       if (src_size >= ETH_ZLEN) {
>           return false;
>       }
>       /* pad to minimum ethernet frame length */
>       memcpy(padded_pkt, pkt, pkt_size);
>       memset(&padded_pkt[pkt_size], 0, ETH_ZLEN - padded_buflen);
>       *padded_buflen = ETH_ZLEN;
>
>       return true;
>   }
>
> What do you think?

Looks good to me. Will update in the next version.

Regards,
Bin

Re: [PATCH v3 04/13] net: tap: Pad short frames to minimum size before send

[Philippe Mathieu-Daudé]

On 3/16/21 9:12 AM, Bin Meng wrote:
> Do the same for tap backend as what we did for slirp.

You explained SLiRP/TAP in the previous patch. IMO these
changes could be squashed there directly (besides, same
maintainer entry).

> 
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> 
> ---
> 
> Changes in v3:
> - use the pad_short_frame() helper for tap
> 
>  net/tap-win32.c | 9 +++++++++
>  net/tap.c       | 9 +++++++++
>  2 files changed, 18 insertions(+)
> 
> diff --git a/net/tap-win32.c b/net/tap-win32.c
> index 2b5dcda36e..e044a5ca35 100644
> --- a/net/tap-win32.c
> +++ b/net/tap-win32.c
> @@ -31,6 +31,7 @@
>  
>  #include "qemu-common.h"
>  #include "clients.h"            /* net_init_tap */
> +#include "net/eth.h"
>  #include "net/net.h"
>  #include "net/tap.h"            /* tap_has_ufo, ... */
>  #include "qemu/error-report.h"
> @@ -688,9 +689,17 @@ static void tap_win32_send(void *opaque)
>      uint8_t *buf;
>      int max_size = 4096;
>      int size;
> +    uint8_t min_pkt[ETH_ZLEN];
>  
>      size = tap_win32_read(s->handle, &buf, max_size);
>      if (size > 0) {
> +        if (!s->nc.peer->do_not_pad) {
> +            if (pad_short_frame(min_pkt, buf, size)) {
> +                buf = min_pkt;
> +                size = ETH_ZLEN;
> +            }
> +        }
> +
>          qemu_send_packet(&s->nc, buf, size);
>          tap_win32_free_buffer(s->handle, buf);
>      }
> diff --git a/net/tap.c b/net/tap.c
> index b7512853f4..aa69cf1c73 100644
> --- a/net/tap.c
> +++ b/net/tap.c
> @@ -32,6 +32,7 @@
>  #include <sys/socket.h>
>  #include <net/if.h>
>  
> +#include "net/eth.h"
>  #include "net/net.h"
>  #include "clients.h"
>  #include "monitor/monitor.h"
> @@ -189,6 +190,7 @@ static void tap_send(void *opaque)
>  
>      while (true) {
>          uint8_t *buf = s->buf;
> +        uint8_t min_pkt[ETH_ZLEN];
>  
>          size = tap_read_packet(s->fd, s->buf, sizeof(s->buf));
>          if (size <= 0) {
> @@ -200,6 +202,13 @@ static void tap_send(void *opaque)
>              size -= s->host_vnet_hdr_len;
>          }
>  
> +        if (!s->nc.peer->do_not_pad) {
> +            if (pad_short_frame(min_pkt, buf, size)) {
> +                buf = min_pkt;
> +                size = ETH_ZLEN;
> +            }
> +        }
> +
>          size = qemu_send_packet_async(&s->nc, buf, size, tap_send_completed);
>          if (size == 0) {
>              tap_read_poll(s, false);
>