Series comparison

 [Qemu-devel] [PULL 0/6] Net patches
-The following changes since commit 2e02083438962d26ef9dcc7100f3b378104183db:
+The following changes since commit e607bbee553cfe73072870cef458cfa4e78133e2:
-  Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (2017-11-17 19:08:07 +0000)
+  Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-01-26.for-upstream' into staging (2018-01-26 14:24:25 +0000)
 are available in the git repository at:
   https://github.com/jasowang/qemu.git tags/net-pull-request
-for you to fetch changes up to c527e0afcd7d719abc3a5ca5e4c8ac2fe48b999f:
+for you to fetch changes up to bf4835a4d5338bb7424827715df22570a8adc67c:
-  hw/net/vmxnet3: Fix code to work on big endian hosts, too (2017-11-20 11:08:00 +0800)
+  MAINTAINERS: update Dmitry Fleytman email (2018-01-29 16:05:38 +0800)
 ----------------------------------------------------------------
 ----------------------------------------------------------------
-Ed Swierk (1):
+Mao Zhongyi (2):
-      net: Transmit zero UDP checksum as 0xFFFF
+      colo: modified the payload compare function
       colo: compare the packet based on the tcp sequence number
-Jason Wang (1):
+Philippe Mathieu-Daudé (1):
-      Revert "Add new PCI ID for i82559a"
+      MAINTAINERS: update Dmitry Fleytman email
-Mao Zhongyi (1):
+Thomas Huth (3):
-      colo-compare: fix the dangerous assignment
+      net: Allow hubports to connect to other netdevs
       net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove'
       qemu-doc: Get rid of "vlan=X" example in the documentation
-Stefan Weil (1):
+ MAINTAINERS        |   8 +-
-      MAINTAINERS: Add missing entry for eepro100 emulation
+ hmp-commands.hx    |   4 +-
+ net/colo-compare.c | 411 +++++++++++++++++++++++++++++++++--------------------
-Thomas Huth (2):
+ net/colo.c         |   9 ++
-      hw/net/eepro100: Fix endianness problem on big endian hosts
+ net/colo.h         |  15 ++
-      hw/net/vmxnet3: Fix code to work on big endian hosts, too
+ net/hub.c          |  27 +++-
+ net/hub.h          |   3 +-
- MAINTAINERS            |   5 ++
+ net/net.c          |   2 +-
- hw/net/e1000.c         |   2 +-
+ net/slirp.c        |  33 +++--
- hw/net/eepro100.c      |  17 +---
+ net/trace-events   |   2 +-
- hw/net/net_rx_pkt.c    |   2 +-
+ qapi/net.json      |   4 +-
- hw/net/net_tx_pkt.c    |   2 +-
+ qemu-options.hx    |  12 +-
- hw/net/vmware_utils.h  |   6 ++
+files changed, 347 insertions(+), 183 deletions(-)
  hw/net/vmxnet3.c       |  49 ++++++++---
  hw/net/vmxnet3.h       | 230 ++++++++++++++++++++++++++++++-------------------
  include/hw/compat.h    |   4 -
  include/hw/pci/pci.h   |   1 -
  include/net/checksum.h |   6 ++
  net/colo-compare.c     |   2 +-
  qemu-options.hx        |   2 +-
 files changed, 201 insertions(+), 127 deletions(-)

-[Qemu-devel] [PULL 5/6] net: Transmit zero UDP checksum as 0xFFFF
+[Qemu-devel] [PULL 1/6] colo: modified the payload compare function
-From: Ed Swierk <eswierk@skyportsystems.com>
+From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
-The checksum algorithm used by IPv4, TCP and UDP allows a zero value
+Modified the function colo_packet_compare_common to prepare for the
-to be represented by either 0x0000 and 0xFFFF. But per RFC 768, a zero
+tcp packet comparison in the next patch.
 UDP checksum must be transmitted as 0xFFFF because 0x0000 is a special
 value meaning no checksum.
-Substitute 0xFFFF whenever a checksum is computed as zero when
+Cc: Zhang Chen <zhangckid@gmail.com>
-modifying a UDP datagram header. Doing this on IPv4 and TCP checksums
+Cc: Li Zhijian <lizhijian@cn.fujitsu.com>
-is unnecessary but legal. Add a wrapper for net_checksum_finish() that
+Cc: Jason Wang <jasowang@redhat.com>
 makes the substitution.
-(We can't just change net_checksum_finish(), as that function is also
+Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
-used by receivers to verify checksums, and in that case the expected
+Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
-value is always 0x0000.)
+Signed-off-by: Zhang Chen <zhangckid@gmail.com>
+Reviewed-by: Zhang Chen <zhangckid@gmail.com>
 Signed-off-by: Ed Swierk <eswierk@skyportsystems.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/e1000.c         | 2 +-
+ net/colo-compare.c | 88 +++++++++++++++++++++++++++---------------------------
- hw/net/net_rx_pkt.c    | 2 +-
+file changed, 44 insertions(+), 44 deletions(-)
  hw/net/net_tx_pkt.c    | 2 +-
  hw/net/vmxnet3.c       | 3 ++-
  include/net/checksum.h | 6 ++++++
 files changed, 11 insertions(+), 4 deletions(-)
-diff --git a/hw/net/e1000.c b/hw/net/e1000.c
+diff --git a/net/colo-compare.c b/net/colo-compare.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/e1000.c
+--- a/net/colo-compare.c
-+++ b/hw/net/e1000.c
++++ b/net/colo-compare.c
-@@ -XXX,XX +XXX,XX @@ putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
+@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
-         n = cse + 1;
+  * return:    0  means packet same
-     if (sloc < n-1) {
+  *            > 0 || < 0 means packet different
-         sum = net_checksum_add(n-css, data+css);
+  */
--        stw_be_p(data + sloc, net_checksum_finish(sum));
+-static int colo_packet_compare_common(Packet *ppkt,
-+        stw_be_p(data + sloc, net_checksum_finish_nozero(sum));
+-                                      Packet *spkt,
 -                                      int poffset,
 -                                      int soffset)
 +static int colo_compare_packet_payload(Packet *ppkt,
 +                                       Packet *spkt,
 +                                       uint16_t poffset,
 +                                       uint16_t soffset,
 +                                       uint16_t len)
 +
  {
      if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
          char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_common(Packet *ppkt,
                                     sec_ip_src, sec_ip_dst);
      }
+-    poffset = ppkt->vnet_hdr_len + poffset;
+-    soffset = ppkt->vnet_hdr_len + soffset;
+-
+-    if (ppkt->size - poffset == spkt->size - soffset) {
+-        return memcmp(ppkt->data + poffset,
+-                      spkt->data + soffset,
+-                      spkt->size - soffset);
+-    } else {
+-        trace_colo_compare_main("Net packet size are not the same");
+-        return -1;
+-    }
++    return memcmp(ppkt->data + poffset, spkt->data + soffset, len);
  }
-diff --git a/hw/net/net_rx_pkt.c b/hw/net/net_rx_pkt.c
+ /*
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
---- a/hw/net/net_rx_pkt.c
+      * the secondary guest's timestamp. COLO just focus on payload,
-+++ b/hw/net/net_rx_pkt.c
+      * so we just need skip this field.
-@@ -XXX,XX +XXX,XX @@ _net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
+      */
-     cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
+-    if (ptcp->th_off > 5) {
-                                  pkt->l4hdr_off, csl, cso);
+-        ptrdiff_t ptcp_offset, stcp_offset;
--    csum = net_checksum_finish(cntr);
+-        ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
-+    csum = net_checksum_finish_nozero(cntr);
+-                      + (ptcp->th_off * 4) - ppkt->vnet_hdr_len;
+-        stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
-     trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);
+-                      + (stcp->th_off * 4) - spkt->vnet_hdr_len;
++    ptrdiff_t ptcp_offset, stcp_offset;
-diff --git a/hw/net/net_tx_pkt.c b/hw/net/net_tx_pkt.c
-index XXXXXXX..XXXXXXX 100644
+-        /*
---- a/hw/net/net_tx_pkt.c
+-         * When network is busy, some tcp options(like sack) will unpredictable
-+++ b/hw/net/net_tx_pkt.c
+-         * occur in primary side or secondary side. it will make packet size
-@@ -XXX,XX +XXX,XX @@ static void net_tx_pkt_do_sw_csum(struct NetTxPkt *pkt)
+-         * not same, but the two packet's payload is identical. colo just
-         net_checksum_add_iov(iov, iov_len, pkt->virt_hdr.csum_start, csl, cso);
+-         * care about packet payload, so we skip the option field.
+-         */
-     /* Put the checksum obtained into the packet */
+-        res = colo_packet_compare_common(ppkt, spkt, ptcp_offset, stcp_offset);
--    csum = cpu_to_be16(net_checksum_finish(csum_cntr));
+-    } else if (ptcp->th_sum == stcp->th_sum) {
-+    csum = cpu_to_be16(net_checksum_finish_nozero(csum_cntr));
+-        res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN, ETH_HLEN);
-     iov_from_buf(iov, iov_len, csum_offset, &csum, sizeof csum);
++    ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
 +                  + (ptcp->th_off << 2) - ppkt->vnet_hdr_len;
 +    stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
 +                  + (stcp->th_off << 2) - spkt->vnet_hdr_len;
 +    if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) {
 +        res = colo_compare_packet_payload(ppkt, spkt,
 +                                          ptcp_offset, stcp_offset,
 +                                          ppkt->size - ptcp_offset);
      } else {
 +        trace_colo_compare_main("TCP: payload size of packets are different");
          res = -1;
      }
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
   */
  static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
  {
 -    int ret;
 -    int network_header_length = ppkt->ip->ip_hl * 4;
 +    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
 +    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
      trace_colo_compare_main("compare udp");
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
       * other field like TOS,TTL,IP Checksum. we only need to compare
       * the ip payload here.
       */
 -    ret = colo_packet_compare_common(ppkt, spkt,
 -                                     network_header_length + ETH_HLEN,
 -                                     network_header_length + ETH_HLEN);
 -
 -    if (ret) {
 +    if (ppkt->size != spkt->size) {
 +        trace_colo_compare_main("UDP: payload size of packets are different");
 +        return -1;
 +    }
 +    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
 +                                    ppkt->size - offset)) {
          trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size);
          trace_colo_compare_udp_miscompare("Secondary pkt size", spkt->size);
          if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
              qemu_hexdump((char *)spkt->data, stderr, "colo-compare sec pkt",
                           spkt->size);
          }
 +        return -1;
 +    } else {
 +        return 0;
      }
 -
 -    return ret;
  }
-diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c
+ /*
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
---- a/hw/net/vmxnet3.c
+  */
-+++ b/hw/net/vmxnet3.c
+ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
-@@ -XXX,XX +XXX,XX @@ static void vmxnet3_rx_need_csum_calculate(struct NetRxPkt *pkt,
+ {
-     data = (uint8_t *)pkt_data + vhdr->csum_start;
+-    int network_header_length = ppkt->ip->ip_hl * 4;
-     len = pkt_len - vhdr->csum_start;
++    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
-     /* Put the checksum obtained into the packet */
++    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
--    stw_be_p(data + vhdr->csum_offset, net_raw_checksum(data, len));
-+    stw_be_p(data + vhdr->csum_offset,
+     trace_colo_compare_main("compare icmp");
-+             net_checksum_finish_nozero(net_checksum_add(len, data)));
+@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
-     vhdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
+      * other field like TOS,TTL,IP Checksum. we only need to compare
-     vhdr->flags |= VIRTIO_NET_HDR_F_DATA_VALID;
+      * the ip payload here.
-diff --git a/include/net/checksum.h b/include/net/checksum.h
+      */
-index XXXXXXX..XXXXXXX 100644
+-    if (colo_packet_compare_common(ppkt, spkt,
---- a/include/net/checksum.h
+-                                   network_header_length + ETH_HLEN,
-+++ b/include/net/checksum.h
+-                                   network_header_length + ETH_HLEN)) {
-@@ -XXX,XX +XXX,XX @@ net_checksum_add(int len, uint8_t *buf)
++    if (ppkt->size != spkt->size) {
 +        trace_colo_compare_main("ICMP: payload size of packets are different");
 +        return -1;
 +    }
 +    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
 +                                    ppkt->size - offset)) {
          trace_colo_compare_icmp_miscompare("primary pkt size",
                                             ppkt->size);
          trace_colo_compare_icmp_miscompare("Secondary pkt size",
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
   */
  static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
  {
 +    uint16_t offset = ppkt->vnet_hdr_len;
 +
      trace_colo_compare_main("compare other");
      if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
          char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
                                     sec_ip_src, sec_ip_dst);
      }
 -    return colo_packet_compare_common(ppkt, spkt, 0, 0);
 +    if (ppkt->size != spkt->size) {
 +        trace_colo_compare_main("Other: payload size of packets are different");
 +        return -1;
 +    }
 +    return colo_compare_packet_payload(ppkt, spkt, offset, offset,
 +                                       ppkt->size - offset);
  }
- static inline uint16_t
+ static int colo_old_packet_check_one(Packet *pkt, int64_t *check_time)
 +net_checksum_finish_nozero(uint32_t sum)
 +{
 +    return net_checksum_finish(sum) ?: 0xFFFF;
 +}
 +
 +static inline uint16_t
  net_raw_checksum(uint8_t *data, int length)
  {
      return net_checksum_finish(net_checksum_add(length, data));
 --
 .7.4

-[Qemu-devel] [PULL 1/6] colo-compare: fix the dangerous assignment
+[Qemu-devel] [PULL 2/6] colo: compare the packet based on the tcp sequence number
 From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
-Cc: Peter Maydell <peter.maydell@linaro.org>
+Packet size some time different or when network is busy.
-Cc: Jason Wang <jasowang@redhat.com>
+Based on same payload size, but TCP protocol can not
 guarantee send the same one packet in the same way,
 like that:
 We send this payload:
 ------------------------------
 | header |1|2|3|4|5|6|7|8|9|0|
 ------------------------------
 primary:
 ppkt1:
 ----------------
 | header |1|2|3|
 ----------------
 ppkt2:
 ------------------------
 | header |4|5|6|7|8|9|0|
 ------------------------
 secondary:
 spkt1:
 ------------------------------
 | header |1|2|3|4|5|6|7|8|9|0|
 ------------------------------
 In the original method, ppkt1 and ppkt2 are different in size and
 spkt1, so they can't compare and trigger the checkpoint.
 I have tested FTP get 200M and 1G file many times, I found that
 the performance was less than 1% of the native.
 Now I reconstructed the comparison of TCP packets based on the
 TCP sequence number. first of all, ppkt1 and spkt1 have the same
 starting sequence number, so they can compare, even though their
 length is different. And then ppkt1 with a smaller payload length
 is used as the comparison length, if the payload is same, send
 out the ppkt1 and record the offset(the length of ppkt1 payload)
 in spkt1. The next comparison, ppkt2 and spkt1 can be compared
 from the recorded position of spkt1.
 like that:
 ----------------
 | header |1|2|3| ppkt1
 ---------|-----|
          |     |
 ---------v-----v--------------
 | header |1|2|3|4|5|6|7|8|9|0| spkt1
 ---------------|\------------|
                | \offset     |
       ---------v-------------v
       | header |4|5|6|7|8|9|0| ppkt2
       ------------------------
 In this way, the performance can reach native 20% in my multiple
 tests.
 Cc: Zhang Chen <zhangckid@gmail.com>
 Cc: Li Zhijian <lizhijian@cn.fujitsu.com>
-Cc: Paolo Bonzini <pbonzini@redhat.com>
+Cc: Jason Wang <jasowang@redhat.com>
-Fixes: 8ec14402029d783720f4312ed8a925548e1dad61
 Reported-by: Peter Maydell <peter.maydell@linaro.org>
 Reported-by: Paolo Bonzini <pbonzini@redhat.com>
 Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
-Reviewed-by: Darren Kenny <darren.kenny@oracle.com>
+Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
 Signed-off-by: Zhang Chen <zhangckid@gmail.com>
 Reviewed-by: Zhang Chen <zhangckid@gmail.com>
 Tested-by: Zhang Chen <zhangckid@gmail.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 2 +-
+ net/colo-compare.c | 343 +++++++++++++++++++++++++++++++++++------------------
-file changed, 1 insertion(+), 1 deletion(-)
+ net/colo.c         |   9 ++
  net/colo.h         |  15 +++
  net/trace-events   |   2 +-
 files changed, 250 insertions(+), 119 deletions(-)
 diff --git a/net/colo-compare.c b/net/colo-compare.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/colo-compare.c
 +++ b/net/colo-compare.c
+@@ -XXX,XX +XXX,XX @@
+ #define COMPARE_READ_LEN_MAX NET_BUFSIZE
+ #define MAX_QUEUE_SIZE 1024
++#define COLO_COMPARE_FREE_PRIMARY     0x01
++#define COLO_COMPARE_FREE_SECONDARY   0x02
++
+ /* TODO: Should be configurable */
+ #define REGULAR_PACKET_CHECK_MS 3000
+@@ -XXX,XX +XXX,XX @@ static gint seq_sorter(Packet *a, Packet *b, gpointer data)
+     return ntohl(atcp->th_seq) - ntohl(btcp->th_seq);
+ }
++static void fill_pkt_tcp_info(void *data, uint32_t *max_ack)
++{
++    Packet *pkt = data;
++    struct tcphdr *tcphd;
++
++    tcphd = (struct tcphdr *)pkt->transport_header;
++
++    pkt->tcp_seq = ntohl(tcphd->th_seq);
++    pkt->tcp_ack = ntohl(tcphd->th_ack);
++    *max_ack = *max_ack > pkt->tcp_ack ? *max_ack : pkt->tcp_ack;
++    pkt->header_size = pkt->transport_header - (uint8_t *)pkt->data
++                       + (tcphd->th_off << 2) - pkt->vnet_hdr_len;
++    pkt->payload_size = pkt->size - pkt->header_size;
++    pkt->seq_end = pkt->tcp_seq + pkt->payload_size;
++    pkt->flags = tcphd->th_flags;
++}
++
+ /*
+  * Return 1 on success, if return 0 means the
+  * packet will be dropped
+  */
+-static int colo_insert_packet(GQueue *queue, Packet *pkt)
++static int colo_insert_packet(GQueue *queue, Packet *pkt, uint32_t *max_ack)
+ {
+     if (g_queue_get_length(queue) <= MAX_QUEUE_SIZE) {
+         if (pkt->ip->ip_p == IPPROTO_TCP) {
++            fill_pkt_tcp_info(pkt, max_ack);
+             g_queue_insert_sorted(queue,
+                                   pkt,
+                                   (GCompareDataFunc)seq_sorter,
 @@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
+     }
+     if (mode == PRIMARY_IN) {
+-        if (!colo_insert_packet(&conn->primary_list, pkt)) {
++        if (!colo_insert_packet(&conn->primary_list, pkt, &conn->pack)) {
+             error_report("colo compare primary queue size too big,"
                           "drop packet");
          }
+     } else {
+-        if (!colo_insert_packet(&conn->secondary_list, pkt)) {
++        if (!colo_insert_packet(&conn->secondary_list, pkt, &conn->sack)) {
+             error_report("colo compare secondary queue size too big,"
+                          "drop packet");
+         }
+@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
+     return 0;
+ }
++static inline bool after(uint32_t seq1, uint32_t seq2)
++{
++        return (int32_t)(seq1 - seq2) > 0;
++}
++
++static void colo_release_primary_pkt(CompareState *s, Packet *pkt)
++{
++    int ret;
++    ret = compare_chr_send(s,
++                           pkt->data,
++                           pkt->size,
++                           pkt->vnet_hdr_len);
++    if (ret < 0) {
++        error_report("colo send primary packet failed");
++    }
++    trace_colo_compare_main("packet same and release packet");
++    packet_destroy(pkt, NULL);
++}
++
+ /*
+  * The IP packets sent by primary and secondary
+  * will be compared in here
+@@ -XXX,XX +XXX,XX @@ static int colo_compare_packet_payload(Packet *ppkt,
+ }
+ /*
+- * Called from the compare thread on the primary
+- * for compare tcp packet
+- * compare_tcp copied from Dr. David Alan Gilbert's branch
+- */
+-static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
++ * return true means that the payload is consist and
++ * need to make the next comparison, false means do
++ * the checkpoint
++*/
++static bool colo_mark_tcp_pkt(Packet *ppkt, Packet *spkt,
++                              int8_t *mark, uint32_t max_ack)
+ {
+-    struct tcphdr *ptcp, *stcp;
+-    int res;
++    *mark = 0;
++
++    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
++        if (colo_compare_packet_payload(ppkt, spkt,
++                                        ppkt->header_size, spkt->header_size,
++                                        ppkt->payload_size)) {
++            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
++            return true;
++        }
++    }
++    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
++        if (colo_compare_packet_payload(ppkt, spkt,
++                                        ppkt->header_size, spkt->header_size,
++                                        ppkt->payload_size)) {
++            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
++            return true;
++        }
++    }
++
++    /* one part of secondary packet payload still need to be compared */
++    if (!after(ppkt->seq_end, spkt->seq_end)) {
++        if (colo_compare_packet_payload(ppkt, spkt,
++                                        ppkt->header_size + ppkt->offset,
++                                        spkt->header_size + spkt->offset,
++                                        ppkt->payload_size - ppkt->offset)) {
++            if (!after(ppkt->tcp_ack, max_ack)) {
++                *mark = COLO_COMPARE_FREE_PRIMARY;
++                spkt->offset += ppkt->payload_size - ppkt->offset;
++                return true;
++            } else {
++                /* secondary guest hasn't ack the data, don't send
++                 * out this packet
++                 */
++                return false;
++            }
++        }
++    } else {
++        /* primary packet is longer than secondary packet, compare
++         * the same part and mark the primary packet offset
++         */
++        if (colo_compare_packet_payload(ppkt, spkt,
++                                        ppkt->header_size + ppkt->offset,
++                                        spkt->header_size + spkt->offset,
++                                        spkt->payload_size - spkt->offset)) {
++            *mark = COLO_COMPARE_FREE_SECONDARY;
++            ppkt->offset += spkt->payload_size - spkt->offset;
++            return true;
++        }
++    }
+-    trace_colo_compare_main("compare tcp");
++    return false;
++}
+-    ptcp = (struct tcphdr *)ppkt->transport_header;
+-    stcp = (struct tcphdr *)spkt->transport_header;
++static void colo_compare_tcp(CompareState *s, Connection *conn)
++{
++    Packet *ppkt = NULL, *spkt = NULL;
++    int8_t mark;
+     /*
+-     * The 'identification' field in the IP header is *very* random
+-     * it almost never matches.  Fudge this by ignoring differences in
+-     * unfragmented packets; they'll normally sort themselves out if different
+-     * anyway, and it should recover at the TCP level.
+-     * An alternative would be to get both the primary and secondary to rewrite
+-     * somehow; but that would need some sync traffic to sync the state
+-     */
+-    if (ntohs(ppkt->ip->ip_off) & IP_DF) {
+-        spkt->ip->ip_id = ppkt->ip->ip_id;
+-        /* and the sum will be different if the IDs were different */
+-        spkt->ip->ip_sum = ppkt->ip->ip_sum;
++     * If ppkt and spkt have the same payload, but ppkt's ACK
++     * is greater than spkt's ACK, in this case we can not
++     * send the ppkt because it will cause the secondary guest
++     * to miss sending some data in the next. Therefore, we
++     * record the maximum ACK in the current queue at both
++     * primary side and secondary side. Only when the ack is
++     * less than the smaller of the two maximum ack, then we
++     * can ensure that the packet's payload is acknowledged by
++     * primary and secondary.
++    */
++    uint32_t min_ack = conn->pack > conn->sack ? conn->sack : conn->pack;
++
++pri:
++    if (g_queue_is_empty(&conn->primary_list)) {
++        return;
      }
--    con = &conn;
++    ppkt = g_queue_pop_head(&conn->primary_list);
-+    *con = conn;
++sec:
++    if (g_queue_is_empty(&conn->secondary_list)) {
-     return 0;
++        g_queue_push_head(&conn->primary_list, ppkt);
- }
++        return;
 +    }
 +    spkt = g_queue_pop_head(&conn->secondary_list);
 -    /*
 -     * Check tcp header length for tcp option field.
 -     * th_off > 5 means this tcp packet have options field.
 -     * The tcp options maybe always different.
 -     * for example:
 -     * From RFC 7323.
 -     * TCP Timestamps option (TSopt):
 -     * Kind: 8
 -     *
 -     * Length: 10 bytes
 -     *
 -     *    +-------+-------+---------------------+---------------------+
 -     *    |Kind=8 |  10   |   TS Value (TSval)  |TS Echo Reply (TSecr)|
 -     *    +-------+-------+---------------------+---------------------+
 -     *       1       1              4                     4
 -     *
 -     * In this case the primary guest's timestamp always different with
 -     * the secondary guest's timestamp. COLO just focus on payload,
 -     * so we just need skip this field.
 -     */
 +    if (ppkt->tcp_seq == ppkt->seq_end) {
 +        colo_release_primary_pkt(s, ppkt);
 +        ppkt = NULL;
 +    }
 -    ptrdiff_t ptcp_offset, stcp_offset;
 +    if (ppkt && conn->compare_seq && !after(ppkt->seq_end, conn->compare_seq)) {
 +        trace_colo_compare_main("pri: this packet has compared");
 +        colo_release_primary_pkt(s, ppkt);
 +        ppkt = NULL;
 +    }
 -    ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
 -                  + (ptcp->th_off << 2) - ppkt->vnet_hdr_len;
 -    stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
 -                  + (stcp->th_off << 2) - spkt->vnet_hdr_len;
 -    if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) {
 -        res = colo_compare_packet_payload(ppkt, spkt,
 -                                          ptcp_offset, stcp_offset,
 -                                          ppkt->size - ptcp_offset);
 +    if (spkt->tcp_seq == spkt->seq_end) {
 +        packet_destroy(spkt, NULL);
 +        if (!ppkt) {
 +            goto pri;
 +        } else {
 +            goto sec;
 +        }
      } else {
 -        trace_colo_compare_main("TCP: payload size of packets are different");
 -        res = -1;
 +        if (conn->compare_seq && !after(spkt->seq_end, conn->compare_seq)) {
 +            trace_colo_compare_main("sec: this packet has compared");
 +            packet_destroy(spkt, NULL);
 +            if (!ppkt) {
 +                goto pri;
 +            } else {
 +                goto sec;
 +            }
 +        }
 +        if (!ppkt) {
 +            g_queue_push_head(&conn->secondary_list, spkt);
 +            goto pri;
 +        }
      }
 -    if (res != 0 &&
 -        trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
 -        char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
 -
 -        strcpy(pri_ip_src, inet_ntoa(ppkt->ip->ip_src));
 -        strcpy(pri_ip_dst, inet_ntoa(ppkt->ip->ip_dst));
 -        strcpy(sec_ip_src, inet_ntoa(spkt->ip->ip_src));
 -        strcpy(sec_ip_dst, inet_ntoa(spkt->ip->ip_dst));
 -
 -        trace_colo_compare_ip_info(ppkt->size, pri_ip_src,
 -                                   pri_ip_dst, spkt->size,
 -                                   sec_ip_src, sec_ip_dst);
 -
 -        trace_colo_compare_tcp_info("pri tcp packet",
 -                                    ntohl(ptcp->th_seq),
 -                                    ntohl(ptcp->th_ack),
 -                                    res, ptcp->th_flags,
 -                                    ppkt->size);
 -
 -        trace_colo_compare_tcp_info("sec tcp packet",
 -                                    ntohl(stcp->th_seq),
 -                                    ntohl(stcp->th_ack),
 -                                    res, stcp->th_flags,
 -                                    spkt->size);
 +    if (colo_mark_tcp_pkt(ppkt, spkt, &mark, min_ack)) {
 +        trace_colo_compare_tcp_info("pri",
 +                                    ppkt->tcp_seq, ppkt->tcp_ack,
 +                                    ppkt->header_size, ppkt->payload_size,
 +                                    ppkt->offset, ppkt->flags);
 +
 +        trace_colo_compare_tcp_info("sec",
 +                                    spkt->tcp_seq, spkt->tcp_ack,
 +                                    spkt->header_size, spkt->payload_size,
 +                                    spkt->offset, spkt->flags);
 +
 +        if (mark == COLO_COMPARE_FREE_PRIMARY) {
 +            conn->compare_seq = ppkt->seq_end;
 +            colo_release_primary_pkt(s, ppkt);
 +            g_queue_push_head(&conn->secondary_list, spkt);
 +            goto pri;
 +        }
 +        if (mark == COLO_COMPARE_FREE_SECONDARY) {
 +            conn->compare_seq = spkt->seq_end;
 +            packet_destroy(spkt, NULL);
 +            goto sec;
 +        }
 +        if (mark == (COLO_COMPARE_FREE_PRIMARY | COLO_COMPARE_FREE_SECONDARY)) {
 +            conn->compare_seq = ppkt->seq_end;
 +            colo_release_primary_pkt(s, ppkt);
 +            packet_destroy(spkt, NULL);
 +            goto pri;
 +        }
 +    } else {
 +        g_queue_push_head(&conn->primary_list, ppkt);
 +        g_queue_push_head(&conn->secondary_list, spkt);
          qemu_hexdump((char *)ppkt->data, stderr,
                       "colo-compare ppkt", ppkt->size);
          qemu_hexdump((char *)spkt->data, stderr,
                       "colo-compare spkt", spkt->size);
 -    }
 -    return res;
 +        /*
 +         * colo_compare_inconsistent_notify();
 +         * TODO: notice to checkpoint();
 +         */
 +    }
  }
 +
  /*
   * Called from the compare thread on the primary
   * for compare udp packet
@@ -XXX,XX +XXX,XX @@ static void colo_old_packet_check(void *opaque)
                          (GCompareFunc)colo_old_packet_check_one_conn);
  }
 -/*
 - * Called from the compare thread on the primary
 - * for compare packet with secondary list of the
 - * specified connection when a new packet was
 - * queued to it.
 - */
 -static void colo_compare_connection(void *opaque, void *user_data)
 +static void colo_compare_packet(CompareState *s, Connection *conn,
 +                                int (*HandlePacket)(Packet *spkt,
 +                                Packet *ppkt))
  {
 -    CompareState *s = user_data;
 -    Connection *conn = opaque;
      Packet *pkt = NULL;
      GList *result = NULL;
 -    int ret;
      while (!g_queue_is_empty(&conn->primary_list) &&
             !g_queue_is_empty(&conn->secondary_list)) {
          pkt = g_queue_pop_head(&conn->primary_list);
 -        switch (conn->ip_proto) {
 -        case IPPROTO_TCP:
 -            result = g_queue_find_custom(&conn->secondary_list,
 -                     pkt, (GCompareFunc)colo_packet_compare_tcp);
 -            break;
 -        case IPPROTO_UDP:
 -            result = g_queue_find_custom(&conn->secondary_list,
 -                     pkt, (GCompareFunc)colo_packet_compare_udp);
 -            break;
 -        case IPPROTO_ICMP:
 -            result = g_queue_find_custom(&conn->secondary_list,
 -                     pkt, (GCompareFunc)colo_packet_compare_icmp);
 -            break;
 -        default:
 -            result = g_queue_find_custom(&conn->secondary_list,
 -                     pkt, (GCompareFunc)colo_packet_compare_other);
 -            break;
 -        }
 +        result = g_queue_find_custom(&conn->secondary_list,
 +                 pkt, (GCompareFunc)HandlePacket);
          if (result) {
 -            ret = compare_chr_send(s,
 -                                   pkt->data,
 -                                   pkt->size,
 -                                   pkt->vnet_hdr_len);
 -            if (ret < 0) {
 -                error_report("colo_send_primary_packet failed");
 -            }
 -            trace_colo_compare_main("packet same and release packet");
 +            colo_release_primary_pkt(s, pkt);
              g_queue_remove(&conn->secondary_list, result->data);
 -            packet_destroy(pkt, NULL);
          } else {
              /*
               * If one packet arrive late, the secondary_list or
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
      }
  }
 +/*
 + * Called from the compare thread on the primary
 + * for compare packet with secondary list of the
 + * specified connection when a new packet was
 + * queued to it.
 + */
 +static void colo_compare_connection(void *opaque, void *user_data)
 +{
 +    CompareState *s = user_data;
 +    Connection *conn = opaque;
 +
 +    switch (conn->ip_proto) {
 +    case IPPROTO_TCP:
 +        colo_compare_tcp(s, conn);
 +        break;
 +    case IPPROTO_UDP:
 +        colo_compare_packet(s, conn, colo_packet_compare_udp);
 +        break;
 +    case IPPROTO_ICMP:
 +        colo_compare_packet(s, conn, colo_packet_compare_icmp);
 +        break;
 +    default:
 +        colo_compare_packet(s, conn, colo_packet_compare_other);
 +        break;
 +    }
 +}
 +
  static int compare_chr_send(CompareState *s,
                              const uint8_t *buf,
                              uint32_t size,
 diff --git a/net/colo.c b/net/colo.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/colo.c
 +++ b/net/colo.c
@@ -XXX,XX +XXX,XX @@ Connection *connection_new(ConnectionKey *key)
      conn->processing = false;
      conn->offset = 0;
      conn->syn_flag = 0;
 +    conn->pack = 0;
 +    conn->sack = 0;
      g_queue_init(&conn->primary_list);
      g_queue_init(&conn->secondary_list);
@@ -XXX,XX +XXX,XX @@ Packet *packet_new(const void *data, int size, int vnet_hdr_len)
      pkt->size = size;
      pkt->creation_ms = qemu_clock_get_ms(QEMU_CLOCK_HOST);
      pkt->vnet_hdr_len = vnet_hdr_len;
 +    pkt->tcp_seq = 0;
 +    pkt->tcp_ack = 0;
 +    pkt->seq_end = 0;
 +    pkt->header_size = 0;
 +    pkt->payload_size = 0;
 +    pkt->offset = 0;
 +    pkt->flags = 0;
      return pkt;
  }
 diff --git a/net/colo.h b/net/colo.h
 index XXXXXXX..XXXXXXX 100644
 --- a/net/colo.h
 +++ b/net/colo.h
@@ -XXX,XX +XXX,XX @@ typedef struct Packet {
      int64_t creation_ms;
      /* Get vnet_hdr_len from filter */
      uint32_t vnet_hdr_len;
 +    uint32_t tcp_seq; /* sequence number */
 +    uint32_t tcp_ack; /* acknowledgement number */
 +    /* the sequence number of the last byte of the packet */
 +    uint32_t seq_end;
 +    uint8_t header_size;  /* the header length */
 +    uint16_t payload_size; /* the payload length */
 +    /* record the payload offset(the length that has been compared) */
 +    uint16_t offset;
 +    uint8_t flags; /* Flags(aka Control bits) */
  } Packet;
  typedef struct ConnectionKey {
@@ -XXX,XX +XXX,XX @@ typedef struct Connection {
      /* flag to enqueue unprocessed_connections */
      bool processing;
      uint8_t ip_proto;
 +    /* record the sequence number that has been compared */
 +    uint32_t compare_seq;
 +    /* the maximum of acknowledgement number in primary_list queue */
 +    uint32_t pack;
 +    /* the maximum of acknowledgement number in secondary_list queue */
 +    uint32_t sack;
      /* offset = secondary_seq - primary_seq */
      tcp_seq  offset;
      /*
 diff --git a/net/trace-events b/net/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/net/trace-events
 +++ b/net/trace-events
@@ -XXX,XX +XXX,XX @@ colo_compare_icmp_miscompare(const char *sta, int size) ": %s = %d"
  colo_compare_ip_info(int psize, const char *sta, const char *stb, int ssize, const char *stc, const char *std) "ppkt size = %d, ip_src = %s, ip_dst = %s, spkt size = %d, ip_src = %s, ip_dst = %s"
  colo_old_packet_check_found(int64_t old_time) "%" PRId64
  colo_compare_miscompare(void) ""
 -colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int res, uint32_t flag, int size) "side: %s seq/ack= %u/%u res= %d flags= 0x%x pkt_size: %d\n"
 +colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int hdlen, int pdlen, int offset, int flags) "%s: seq/ack= %u/%u hdlen= %d pdlen= %d offset= %d flags=%d\n"
  # net/filter-rewriter.c
  colo_filter_rewriter_debug(void) ""
 --
 .7.4

-[Qemu-devel] [PULL 6/6] hw/net/vmxnet3: Fix code to work on big endian hosts, too
+[Qemu-devel] [PULL 3/6] net: Allow hubports to connect to other netdevs
 From: Thomas Huth <thuth@redhat.com>
-Since commit ab06ec43577177a442e8 we test the vmxnet3 device in the
+QEMU can emulate hubs to connect NICs and netdevs. This is currently
-pxe-tester, too (when running "make check SPEED=slow"). This now
+primarily used for the mis-named 'vlan' feature of the networking
-revealed that the code is not working there if the host is a big
+subsystem. Now the 'vlan' feature has been marked as deprecated, since
-endian machine (for example ppc64 or s390x) - "make check SPEED=slow"
+its name is rather confusing and the users often rather mis-configure
-is now failing on such hosts.
+their network when trying to use it. But while the 'vlan' parameter
+should be removed at one point in time, the basic idea of emulating
-The vmxnet3 code lacks endianness conversions in a couple of places.
+a hub in QEMU is still good: It's useful for bundling up the output of
-Interestingly, the bitfields in the structs in vmxnet3.h already tried to
+multiple NICs into one single l2tp netdev for example.
-take care of the *bit* endianness of the C compilers - but the code missed
-to change the *byte* endianness when reading or writing the corresponding
+Now to be able to use the hubport feature without 'vlan's, there is one
-structs. So the bitfields are now wrapped into unions which allow to change
+missing piece: The possibility to connect a hubport to a netdev, too.
-the byte endianness during runtime with the non-bitfield member of the union.
+This patch adds this possibility by introducing a new "netdev=..."
-With these changes, "make check SPEED=slow" now properly works on big endian
+parameter to the hubports.
-hosts, too.
+To bundle up the output of multiple NICs into one socket netdev, you can
-Reported-by: David Gibson <dgibson@redhat.com>
+now run QEMU with these parameters for example:
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Reviewed-by: David Gibson <dgibson@redhat.com>
+qemu-system-ppc64 ... -netdev socket,id=s1,connect=:11122 \
     -netdev hubport,hubid=1,id=h1,netdev=s1 \
     -netdev hubport,hubid=1,id=h2 -device e1000,netdev=h2 \
     -netdev hubport,hubid=1,id=h3 -device virtio-net-pci,netdev=h3
 For using the socket netdev, you have got to start another QEMU as the
 receiving side first, for example with network dumping enabled:
 qemu-system-x86_64 -M isapc -netdev socket,id=s0,listen=:11122 \
     -device ne2k_isa,netdev=s0 \
     -object filter-dump,id=f1,netdev=s0,file=/tmp/dump.dat
 After the ppc64 guest tried to boot from both NICs, you can see in the
 dump file (using Wireshark, for example), that the output of both NICs
 (the e1000 and the virtio-net-pci) has been successfully transfered
 via the socket netdev in this case.
 Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
 Signed-off-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/vmware_utils.h |   6 ++
+ net/hub.c       | 27 +++++++++++++++++++++------
- hw/net/vmxnet3.c      |  46 +++++++---
+ net/hub.h       |  3 ++-
- hw/net/vmxnet3.h      | 230 ++++++++++++++++++++++++++++++--------------------
+ net/net.c       |  2 +-
-files changed, 181 insertions(+), 101 deletions(-)
+ qapi/net.json   |  4 +++-
+ qemu-options.hx |  8 +++++---
-diff --git a/hw/net/vmware_utils.h b/hw/net/vmware_utils.h
+files changed, 32 insertions(+), 12 deletions(-)
-index XXXXXXX..XXXXXXX 100644
---- a/hw/net/vmware_utils.h
+diff --git a/net/hub.c b/net/hub.c
-+++ b/hw/net/vmware_utils.h
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld16(PCIDevice *d, hwaddr addr)
+--- a/net/hub.c
 +++ b/net/hub.c
@@ -XXX,XX +XXX,XX @@
   */
  #include "qemu/osdep.h"
 +#include "qapi/error.h"
  #include "monitor/monitor.h"
  #include "net/net.h"
  #include "clients.h"
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_hub_port_info = {
      .cleanup = net_hub_port_cleanup,
  };
 -static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
 +static NetHubPort *net_hub_port_new(NetHub *hub, const char *name,
 +                                    NetClientState *hubpeer)
  {
-     uint16_t res;
+     NetClientState *nc;
-     pci_dma_read(d, addr, &res, 2);
+     NetHubPort *port;
-+    res = le16_to_cpu(res);
+@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
-     VMW_SHPRN("SHMEM load16: %" PRIx64 " (value 0x%X)", addr, res);
+         name = default_name;
-     return res;
+     }
 -    nc = qemu_new_net_client(&net_hub_port_info, NULL, "hub", name);
 +    nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name);
      port = DO_UPCAST(NetHubPort, nc, nc);
      port->id = id;
      port->hub = hub;
@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
  /**
   * Create a port on a given hub
 + * @hub_id: Number of the hub
   * @name: Net client name or NULL for default name.
 + * @hubpeer: Peer to use (if "netdev=id" has been specified)
   *
   * If there is no existing hub with the given id then a new hub is created.
   */
 -NetClientState *net_hub_add_port(int hub_id, const char *name)
 +NetClientState *net_hub_add_port(int hub_id, const char *name,
 +                                 NetClientState *hubpeer)
  {
      NetHub *hub;
      NetHubPort *port;
@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_add_port(int hub_id, const char *name)
          hub = net_hub_new(hub_id);
      }
 -    port = net_hub_port_new(hub, name);
 +    port = net_hub_port_new(hub, name, hubpeer);
      return &port->nc;
  }
-@@ -XXX,XX +XXX,XX @@ static inline void
- vmw_shmem_st16(PCIDevice *d, hwaddr addr, uint16_t value)
+@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id)
          }
      }
 -    nc = net_hub_add_port(hub_id, NULL);
 +    nc = net_hub_add_port(hub_id, NULL, NULL);
      return nc;
  }
@@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name,
                       NetClientState *peer, Error **errp)
  {
-     VMW_SHPRN("SHMEM store16: %" PRIx64 " (value 0x%X)", addr, value);
+     const NetdevHubPortOptions *hubport;
-+    value = cpu_to_le16(value);
++    NetClientState *hubpeer = NULL;
-     pci_dma_write(d, addr, &value, 2);
      assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT);
      assert(!peer);
      hubport = &netdev->u.hubport;
 -    net_hub_add_port(hubport->hubid, name);
 +    if (hubport->has_netdev) {
 +        hubpeer = qemu_find_netdev(hubport->netdev);
 +        if (!hubpeer) {
 +            error_setg(errp, "netdev '%s' not found", hubport->netdev);
 +            return -1;
 +        }
 +    }
 +
 +    net_hub_add_port(hubport->hubid, name, hubpeer);
 +
      return 0;
  }
-@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld32(PCIDevice *d, hwaddr addr)
+diff --git a/net/hub.h b/net/hub.h
- {
+index XXXXXXX..XXXXXXX 100644
-     uint32_t res;
+--- a/net/hub.h
-     pci_dma_read(d, addr, &res, 4);
++++ b/net/hub.h
-+    res = le32_to_cpu(res);
+@@ -XXX,XX +XXX,XX @@
-     VMW_SHPRN("SHMEM load32: %" PRIx64 " (value 0x%X)", addr, res);
-     return res;
+ #include "qemu-common.h"
- }
-@@ -XXX,XX +XXX,XX @@ static inline void
+-NetClientState *net_hub_add_port(int hub_id, const char *name);
- vmw_shmem_st32(PCIDevice *d, hwaddr addr, uint32_t value)
++NetClientState *net_hub_add_port(int hub_id, const char *name,
- {
++                                 NetClientState *hubpeer);
-     VMW_SHPRN("SHMEM store32: %" PRIx64 " (value 0x%X)", addr, value);
+ NetClientState *net_hub_find_client_by_name(int hub_id, const char *name);
-+    value = cpu_to_le32(value);
+ void net_hub_info(Monitor *mon);
-     pci_dma_write(d, addr, &value, 4);
+ void net_hub_check_clients(void);
- }
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld64(PCIDevice *d, hwaddr addr)
+--- a/net/net.c
- {
++++ b/net/net.c
-     uint64_t res;
+@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp)
-     pci_dma_read(d, addr, &res, 8);
+         /* Do not add to a vlan if it's a nic with a netdev= parameter. */
-+    res = le64_to_cpu(res);
+         if (netdev->type != NET_CLIENT_DRIVER_NIC ||
-     VMW_SHPRN("SHMEM load64: %" PRIx64 " (value %" PRIx64 ")", addr, res);
+             !opts->u.nic.has_netdev) {
-     return res;
+-            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL);
- }
++            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL, NULL);
@@ -XXX,XX +XXX,XX @@ static inline void
  vmw_shmem_st64(PCIDevice *d, hwaddr addr, uint64_t value)
  {
      VMW_SHPRN("SHMEM store64: %" PRIx64 " (value %" PRIx64 ")", addr, value);
 +    value = cpu_to_le64(value);
      pci_dma_write(d, addr, &value, 8);
  }
 diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/net/vmxnet3.c
 +++ b/hw/net/vmxnet3.c
@@ -XXX,XX +XXX,XX @@ vmxnet3_dump_tx_descr(struct Vmxnet3_TxDesc *descr)
                "addr %" PRIx64 ", len: %d, gen: %d, rsvd: %d, "
                "dtype: %d, ext1: %d, msscof: %d, hlen: %d, om: %d, "
                "eop: %d, cq: %d, ext2: %d, ti: %d, tci: %d",
 -              le64_to_cpu(descr->addr), descr->len, descr->gen, descr->rsvd,
 +              descr->addr, descr->len, descr->gen, descr->rsvd,
                descr->dtype, descr->ext1, descr->msscof, descr->hlen, descr->om,
                descr->eop, descr->cq, descr->ext2, descr->ti, descr->tci);
  }
@@ -XXX,XX +XXX,XX @@ vmxnet3_dump_rx_descr(struct Vmxnet3_RxDesc *descr)
  {
      VMW_PKPRN("RX DESCR: addr %" PRIx64 ", len: %d, gen: %d, rsvd: %d, "
                "dtype: %d, ext1: %d, btype: %d",
 -              le64_to_cpu(descr->addr), descr->len, descr->gen,
 +              descr->addr, descr->len, descr->gen,
                descr->rsvd, descr->dtype, descr->ext1, descr->btype);
  }
@@ -XXX,XX +XXX,XX @@ static void vmxnet3_complete_packet(VMXNET3State *s, int qidx, uint32_t tx_ridx)
      memset(&txcq_descr, 0, sizeof(txcq_descr));
      txcq_descr.txdIdx = tx_ridx;
      txcq_descr.gen = vmxnet3_ring_curr_gen(&s->txq_descr[qidx].comp_ring);
 -
 +    txcq_descr.val1 = cpu_to_le32(txcq_descr.val1);
 +    txcq_descr.val2 = cpu_to_le32(txcq_descr.val2);
      vmxnet3_ring_write_curr_cell(d, &s->txq_descr[qidx].comp_ring, &txcq_descr);
      /* Flush changes in TX descriptor before changing the counter value */
@@ -XXX,XX +XXX,XX @@ vmxnet3_on_rx_done_update_stats(VMXNET3State *s,
      }
  }
 +static inline void
 +vmxnet3_ring_read_curr_txdesc(PCIDevice *pcidev, Vmxnet3Ring *ring,
 +                              struct Vmxnet3_TxDesc *txd)
 +{
 +    vmxnet3_ring_read_curr_cell(pcidev, ring, txd);
 +    txd->addr = le64_to_cpu(txd->addr);
 +    txd->val1 = le32_to_cpu(txd->val1);
 +    txd->val2 = le32_to_cpu(txd->val2);
 +}
 +
  static inline bool
  vmxnet3_pop_next_tx_descr(VMXNET3State *s,
                            int qidx,
@@ -XXX,XX +XXX,XX @@ vmxnet3_pop_next_tx_descr(VMXNET3State *s,
      Vmxnet3Ring *ring = &s->txq_descr[qidx].tx_ring;
      PCIDevice *d = PCI_DEVICE(s);
 -    vmxnet3_ring_read_curr_cell(d, ring, txd);
 +    vmxnet3_ring_read_curr_txdesc(d, ring, txd);
      if (txd->gen == vmxnet3_ring_curr_gen(ring)) {
          /* Only read after generation field verification */
          smp_rmb();
          /* Re-read to be sure we got the latest version */
 -        vmxnet3_ring_read_curr_cell(d, ring, txd);
 +        vmxnet3_ring_read_curr_txdesc(d, ring, txd);
          VMXNET3_RING_DUMP(VMW_RIPRN, "TX", qidx, ring);
          *descr_idx = vmxnet3_ring_curr_cell_idx(ring);
          vmxnet3_inc_tx_consumption_counter(s, qidx);
@@ -XXX,XX +XXX,XX @@ static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
          if (!s->skip_current_tx_pkt) {
              data_len = (txd.len > 0) ? txd.len : VMXNET3_MAX_TX_BUF_SIZE;
 -            data_pa = le64_to_cpu(txd.addr);
 +            data_pa = txd.addr;
              if (!net_tx_pkt_add_raw_fragment(s->tx_pkt,
                                                  data_pa,
@@ -XXX,XX +XXX,XX @@ vmxnet3_read_next_rx_descr(VMXNET3State *s, int qidx, int ridx,
      Vmxnet3Ring *ring = &s->rxq_descr[qidx].rx_ring[ridx];
      *didx = vmxnet3_ring_curr_cell_idx(ring);
      vmxnet3_ring_read_curr_cell(d, ring, dbuf);
 +    dbuf->addr = le64_to_cpu(dbuf->addr);
 +    dbuf->val1 = le32_to_cpu(dbuf->val1);
 +    dbuf->ext1 = le32_to_cpu(dbuf->ext1);
  }
  static inline uint8_t
@@ -XXX,XX +XXX,XX @@ vmxnet3_pop_rxc_descr(VMXNET3State *s, int qidx, uint32_t *descr_gen)
      pci_dma_read(PCI_DEVICE(s),
                   daddr, &rxcd, sizeof(struct Vmxnet3_RxCompDesc));
 +    rxcd.val1 = le32_to_cpu(rxcd.val1);
 +    rxcd.val2 = le32_to_cpu(rxcd.val2);
 +    rxcd.val3 = le32_to_cpu(rxcd.val3);
      ring_gen = vmxnet3_ring_curr_gen(&s->rxq_descr[qidx].comp_ring);
      if (rxcd.gen != ring_gen) {
@@ -XXX,XX +XXX,XX @@ vmxnet3_pci_dma_writev(PCIDevice *pci_dev,
      }
  }
 +static void
 +vmxnet3_pci_dma_write_rxcd(PCIDevice *pcidev, dma_addr_t pa,
 +                           struct Vmxnet3_RxCompDesc *rxcd)
 +{
 +    rxcd->val1 = cpu_to_le32(rxcd->val1);
 +    rxcd->val2 = cpu_to_le32(rxcd->val2);
 +    rxcd->val3 = cpu_to_le32(rxcd->val3);
 +    pci_dma_write(pcidev, pa, rxcd, sizeof(*rxcd));
 +}
 +
  static bool
  vmxnet3_indicate_packet(VMXNET3State *s)
  {
@@ -XXX,XX +XXX,XX @@ vmxnet3_indicate_packet(VMXNET3State *s)
          }
-         chunk_size = MIN(bytes_left, rxd.len);
+         if (net->has_vlan && !vlan_warned) {
--        vmxnet3_pci_dma_writev(d, data, bytes_copied,
+diff --git a/qapi/net.json b/qapi/net.json
--                               le64_to_cpu(rxd.addr), chunk_size);
+index XXXXXXX..XXXXXXX 100644
-+        vmxnet3_pci_dma_writev(d, data, bytes_copied, rxd.addr, chunk_size);
+--- a/qapi/net.json
-         bytes_copied += chunk_size;
++++ b/qapi/net.json
-         bytes_left -= chunk_size;
+@@ -XXX,XX +XXX,XX @@
+ # Connect two or more net clients through a software hub.
-         vmxnet3_dump_rx_descr(&rxd);
+ #
+ # @hubid: hub identifier number
-         if (ready_rxcd_pa != 0) {
++# @netdev: used to connect hub to a netdev instead of a device (since 2.12)
--            pci_dma_write(d, ready_rxcd_pa, &rxcd, sizeof(rxcd));
+ #
-+            vmxnet3_pci_dma_write_rxcd(d, ready_rxcd_pa, &rxcd);
+ # Since: 1.2
-         }
+ ##
+ { 'struct': 'NetdevHubPortOptions',
-         memset(&rxcd, 0, sizeof(struct Vmxnet3_RxCompDesc));
+   'data': {
-@@ -XXX,XX +XXX,XX @@ vmxnet3_indicate_packet(VMXNET3State *s)
+-    'hubid':     'int32' } }
-         rxcd.eop = 1;
++    'hubid':     'int32',
-         rxcd.err = (bytes_left != 0);
++    '*netdev':    'str' } }
--        pci_dma_write(d, ready_rxcd_pa, &rxcd, sizeof(rxcd));
+ ##
-+        vmxnet3_pci_dma_write_rxcd(d, ready_rxcd_pa, &rxcd);
+ # @NetdevNetmapOptions:
+diff --git a/qemu-options.hx b/qemu-options.hx
-         /* Flush RX descriptor changes */
+index XXXXXXX..XXXXXXX 100644
-         smp_wmb();
+--- a/qemu-options.hx
-diff --git a/hw/net/vmxnet3.h b/hw/net/vmxnet3.h
++++ b/qemu-options.hx
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
 --- a/hw/net/vmxnet3.h
 +++ b/hw/net/vmxnet3.h
@@ -XXX,XX +XXX,XX @@ enum {
  struct Vmxnet3_TxDesc {
      __le64 addr;
 +    union {
 +        struct {
  #ifdef __BIG_ENDIAN_BITFIELD
 -    u32 msscof:14;  /* MSS, checksum offset, flags */
 -    u32 ext1:1;
 -    u32 dtype:1;    /* descriptor type */
 -    u32 rsvd:1;
 -    u32 gen:1;      /* generation bit */
 -    u32 len:14;
 +            u32 msscof:14;  /* MSS, checksum offset, flags */
 +            u32 ext1:1;
 +            u32 dtype:1;    /* descriptor type */
 +            u32 rsvd:1;
 +            u32 gen:1;      /* generation bit */
 +            u32 len:14;
  #else
 -    u32 len:14;
 -    u32 gen:1;      /* generation bit */
 -    u32 rsvd:1;
 -    u32 dtype:1;    /* descriptor type */
 -    u32 ext1:1;
 -    u32 msscof:14;  /* MSS, checksum offset, flags */
 +            u32 len:14;
 +            u32 gen:1;      /* generation bit */
 +            u32 rsvd:1;
 +            u32 dtype:1;    /* descriptor type */
 +            u32 ext1:1;
 +            u32 msscof:14;  /* MSS, checksum offset, flags */
  #endif  /* __BIG_ENDIAN_BITFIELD */
 -
 +        };
 +        u32 val1;
 +    };
 +
 +    union {
 +        struct {
  #ifdef __BIG_ENDIAN_BITFIELD
 -    u32 tci:16;     /* Tag to Insert */
 -    u32 ti:1;       /* VLAN Tag Insertion */
 -    u32 ext2:1;
 -    u32 cq:1;       /* completion request */
 -    u32 eop:1;      /* End Of Packet */
 -    u32 om:2;       /* offload mode */
 -    u32 hlen:10;    /* header len */
 +            u32 tci:16;     /* Tag to Insert */
 +            u32 ti:1;       /* VLAN Tag Insertion */
 +            u32 ext2:1;
 +            u32 cq:1;       /* completion request */
 +            u32 eop:1;      /* End Of Packet */
 +            u32 om:2;       /* offload mode */
 +            u32 hlen:10;    /* header len */
  #else
 -    u32 hlen:10;    /* header len */
 -    u32 om:2;       /* offload mode */
 -    u32 eop:1;      /* End Of Packet */
 -    u32 cq:1;       /* completion request */
 -    u32 ext2:1;
 -    u32 ti:1;       /* VLAN Tag Insertion */
 -    u32 tci:16;     /* Tag to Insert */
 +            u32 hlen:10;    /* header len */
 +            u32 om:2;       /* offload mode */
 +            u32 eop:1;      /* End Of Packet */
 +            u32 cq:1;       /* completion request */
 +            u32 ext2:1;
 +            u32 ti:1;       /* VLAN Tag Insertion */
 +            u32 tci:16;     /* Tag to Insert */
  #endif  /* __BIG_ENDIAN_BITFIELD */
 +        };
 +        u32 val2;
 +    };
  };
  /* TxDesc.OM values */
@@ -XXX,XX +XXX,XX @@ struct Vmxnet3_TxDataDesc {
  #define VMXNET3_TCD_GEN_DWORD_SHIFT    3
  struct Vmxnet3_TxCompDesc {
 -    u32        txdIdx:12;    /* Index of the EOP TxDesc */
 -    u32        ext1:20;
 -
 +    union {
 +        struct {
 +#ifdef __BIG_ENDIAN_BITFIELD
 +            u32 ext1:20;
 +            u32 txdIdx:12;    /* Index of the EOP TxDesc */
 +#else
 +            u32 txdIdx:12;    /* Index of the EOP TxDesc */
 +            u32 ext1:20;
 +#endif
 +        };
 +        u32 val1;
 +    };
      __le32        ext2;
      __le32        ext3;
 -    u32        rsvd:24;
 -    u32        type:7;       /* completion type */
 -    u32        gen:1;        /* generation bit */
 +    union {
 +        struct {
 +#ifdef __BIG_ENDIAN_BITFIELD
 +            u32 gen:1;        /* generation bit */
 +            u32 type:7;       /* completion type */
 +            u32 rsvd:24;
 +#else
 +            u32 rsvd:24;
 +            u32 type:7;       /* completion type */
 +            u32 gen:1;        /* generation bit */
 +#endif
 +        };
 +        u32 val2;
 +    };
  };
  struct Vmxnet3_RxDesc {
      __le64        addr;
 -
 +    union {
 +        struct {
  #ifdef __BIG_ENDIAN_BITFIELD
 -    u32        gen:1;        /* Generation bit */
 -    u32        rsvd:15;
 -    u32        dtype:1;      /* Descriptor type */
 -    u32        btype:1;      /* Buffer Type */
 -    u32        len:14;
 +            u32 gen:1;        /* Generation bit */
 +            u32 rsvd:15;
 +            u32 dtype:1;      /* Descriptor type */
 +            u32 btype:1;      /* Buffer Type */
 +            u32 len:14;
  #else
 -    u32        len:14;
 -    u32        btype:1;      /* Buffer Type */
 -    u32        dtype:1;      /* Descriptor type */
 -    u32        rsvd:15;
 -    u32        gen:1;        /* Generation bit */
 +            u32 len:14;
 +            u32 btype:1;      /* Buffer Type */
 +            u32 dtype:1;      /* Descriptor type */
 +            u32 rsvd:15;
 +            u32 gen:1;        /* Generation bit */
  #endif
-+        };
+     "-netdev vhost-user,id=str,chardev=dev[,vhostforce=on|off]\n"
-+        u32 val1;
+     "                configure a vhost-user network, backed by a chardev 'dev'\n"
-+    };
+-    "-netdev hubport,id=str,hubid=n\n"
-     u32        ext1;
++    "-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
- };
+     "                configure a hub port on QEMU VLAN 'n'\n", QEMU_ARCH_ALL)
+ DEF("net", HAS_ARG, QEMU_OPTION_net,
-@@ -XXX,XX +XXX,XX @@ struct Vmxnet3_RxDesc {
+     "-net nic[,vlan=n][,netdev=nd][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n"
- #define VMXNET3_RXD_GEN_SHIFT    31
+@@ -XXX,XX +XXX,XX @@ vde_switch -F -sock /tmp/myswitch
+ qemu-system-i386 linux.img -net nic -net vde,sock=/tmp/myswitch
- struct Vmxnet3_RxCompDesc {
+ @end example
-+    union {
-+        struct {
+-@item -netdev hubport,id=@var{id},hubid=@var{hubid}
- #ifdef __BIG_ENDIAN_BITFIELD
++@item -netdev hubport,id=@var{id},hubid=@var{hubid}[,netdev=@var{nd}]
--    u32        ext2:1;
--    u32        cnc:1;        /* Checksum Not Calculated */
+ Create a hub port on QEMU "vlan" @var{hubid}.
--    u32        rssType:4;    /* RSS hash type used */
--    u32        rqID:10;      /* rx queue/ring ID */
+ The hubport netdev lets you connect a NIC to a QEMU "vlan" instead of a single
--    u32        sop:1;        /* Start of Packet */
+ netdev.  @code{-net} and @code{-device} with parameter @option{vlan} create the
--    u32        eop:1;        /* End of Packet */
+-required hub automatically.
--    u32        ext1:2;
++required hub automatically. Alternatively, you can also connect the hubport
--    u32        rxdIdx:12;    /* Index of the RxDesc */
++to another netdev with ID @var{nd} by using the @option{netdev=@var{nd}}
-+            u32 ext2:1;
++option.
-+            u32 cnc:1;        /* Checksum Not Calculated */
-+            u32 rssType:4;    /* RSS hash type used */
+ @item -netdev vhost-user,chardev=@var{id}[,vhostforce=on|off][,queues=n]
-+            u32 rqID:10;      /* rx queue/ring ID */
 +            u32 sop:1;        /* Start of Packet */
 +            u32 eop:1;        /* End of Packet */
 +            u32 ext1:2;
 +            u32 rxdIdx:12;    /* Index of the RxDesc */
  #else
 -    u32        rxdIdx:12;    /* Index of the RxDesc */
 -    u32        ext1:2;
 -    u32        eop:1;        /* End of Packet */
 -    u32        sop:1;        /* Start of Packet */
 -    u32        rqID:10;      /* rx queue/ring ID */
 -    u32        rssType:4;    /* RSS hash type used */
 -    u32        cnc:1;        /* Checksum Not Calculated */
 -    u32        ext2:1;
 +            u32 rxdIdx:12;    /* Index of the RxDesc */
 +            u32 ext1:2;
 +            u32 eop:1;        /* End of Packet */
 +            u32 sop:1;        /* Start of Packet */
 +            u32 rqID:10;      /* rx queue/ring ID */
 +            u32 rssType:4;    /* RSS hash type used */
 +            u32 cnc:1;        /* Checksum Not Calculated */
 +            u32 ext2:1;
  #endif  /* __BIG_ENDIAN_BITFIELD */
 +        };
 +        u32 val1;
 +    };
      __le32        rssHash;      /* RSS hash value */
 +    union {
 +        struct {
  #ifdef __BIG_ENDIAN_BITFIELD
 -    u32        tci:16;       /* Tag stripped */
 -    u32        ts:1;         /* Tag is stripped */
 -    u32        err:1;        /* Error */
 -    u32        len:14;       /* data length */
 +            u32 tci:16;       /* Tag stripped */
 +            u32 ts:1;         /* Tag is stripped */
 +            u32 err:1;        /* Error */
 +            u32 len:14;       /* data length */
  #else
 -    u32        len:14;       /* data length */
 -    u32        err:1;        /* Error */
 -    u32        ts:1;         /* Tag is stripped */
 -    u32        tci:16;       /* Tag stripped */
 +            u32 len:14;       /* data length */
 +            u32 err:1;        /* Error */
 +            u32 ts:1;         /* Tag is stripped */
 +            u32 tci:16;       /* Tag stripped */
  #endif  /* __BIG_ENDIAN_BITFIELD */
 +        };
 +        u32 val2;
 +    };
 -
 +    union {
 +        struct {
  #ifdef __BIG_ENDIAN_BITFIELD
 -    u32        gen:1;        /* generation bit */
 -    u32        type:7;       /* completion type */
 -    u32        fcs:1;        /* Frame CRC correct */
 -    u32        frg:1;        /* IP Fragment */
 -    u32        v4:1;         /* IPv4 */
 -    u32        v6:1;         /* IPv6 */
 -    u32        ipc:1;        /* IP Checksum Correct */
 -    u32        tcp:1;        /* TCP packet */
 -    u32        udp:1;        /* UDP packet */
 -    u32        tuc:1;        /* TCP/UDP Checksum Correct */
 -    u32        csum:16;
 +            u32 gen:1;        /* generation bit */
 +            u32 type:7;       /* completion type */
 +            u32 fcs:1;        /* Frame CRC correct */
 +            u32 frg:1;        /* IP Fragment */
 +            u32 v4:1;         /* IPv4 */
 +            u32 v6:1;         /* IPv6 */
 +            u32 ipc:1;        /* IP Checksum Correct */
 +            u32 tcp:1;        /* TCP packet */
 +            u32 udp:1;        /* UDP packet */
 +            u32 tuc:1;        /* TCP/UDP Checksum Correct */
 +            u32 csum:16;
  #else
 -    u32        csum:16;
 -    u32        tuc:1;        /* TCP/UDP Checksum Correct */
 -    u32        udp:1;        /* UDP packet */
 -    u32        tcp:1;        /* TCP packet */
 -    u32        ipc:1;        /* IP Checksum Correct */
 -    u32        v6:1;         /* IPv6 */
 -    u32        v4:1;         /* IPv4 */
 -    u32        frg:1;        /* IP Fragment */
 -    u32        fcs:1;        /* Frame CRC correct */
 -    u32        type:7;       /* completion type */
 -    u32        gen:1;        /* generation bit */
 +            u32 csum:16;
 +            u32 tuc:1;        /* TCP/UDP Checksum Correct */
 +            u32 udp:1;        /* UDP packet */
 +            u32 tcp:1;        /* TCP packet */
 +            u32 ipc:1;        /* IP Checksum Correct */
 +            u32 v6:1;         /* IPv6 */
 +            u32 v4:1;         /* IPv4 */
 +            u32 frg:1;        /* IP Fragment */
 +            u32 fcs:1;        /* Frame CRC correct */
 +            u32 type:7;       /* completion type */
 +            u32 gen:1;        /* generation bit */
  #endif  /* __BIG_ENDIAN_BITFIELD */
 +        };
 +        u32 val3;
 +    };
  };
  /* fields in RxCompDesc we access via Vmxnet3_GenericDesc.dword[3] */
 --
 .7.4

-[Qemu-devel] [PULL 3/6] hw/net/eepro100: Fix endianness problem on big endian hosts
+[Qemu-devel] [PULL 4/6] net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove'
 From: Thomas Huth <thuth@redhat.com>
-Since commit 1865e288a823c764cd4344d ("Fix eepro100 simple transmission
+It does not make much sense to limit these commands to the legacy 'vlan'
-mode"), the test/pxe-test is broken for the eepro100 device on big
+concept only, they should work with the modern netdevs, too. So now
-endian hosts. However, it seems like that commit did not introduce the
+it is possible to use this command with one, two or three parameters.
-problem, but just uncovered it: The EEPRO100State->tx.tbd_array_addr and
-EEPRO100State->tx.tcb_bytes fields are already in host byte order, since
+With one parameter, the command installs a hostfwd rule on the default
-they have already been byte-swapped in the read_cb() function.
+"user" network:
-Thus byte-swapping them in tx_command() again results in the wrong
+    hostfwd_add tcp:...
-endianness. Removing the byte-swapping here fixes the pxe-test.
 With two parameters, the command installs a hostfwd rule on a netdev
 (that's the new way of using this command):
     hostfwd_add netdev_id tcp:...
 With three parameters, the command installs a rule on a 'vlan' (aka hub):
     hostfwd_add hub_id name tcp:...
 Same applies to the hostfwd_remove command now.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/eepro100.c | 4 ++--
+ hmp-commands.hx |  4 ++--
-file changed, 2 insertions(+), 2 deletions(-)
+ net/slirp.c     | 33 +++++++++++++++++++++++----------
 files changed, 25 insertions(+), 12 deletions(-)
-diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c
+diff --git a/hmp-commands.hx b/hmp-commands.hx
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/eepro100.c
+--- a/hmp-commands.hx
-+++ b/hw/net/eepro100.c
++++ b/hmp-commands.hx
-@@ -XXX,XX +XXX,XX @@ static void read_cb(EEPRO100State *s)
+@@ -XXX,XX +XXX,XX @@ ETEXI
+     {
- static void tx_command(EEPRO100State *s)
+         .name       = "hostfwd_add",
          .args_type  = "arg1:s,arg2:s?,arg3:s?",
 -        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
 +        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
          .help       = "redirect TCP or UDP connections from host to guest (requires -net user)",
          .cmd        = hmp_hostfwd_add,
      },
@@ -XXX,XX +XXX,XX @@ ETEXI
      {
          .name       = "hostfwd_remove",
          .args_type  = "arg1:s,arg2:s?,arg3:s?",
 -        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport",
 +        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport",
          .help       = "remove host-to-guest TCP or UDP redirection",
          .cmd        = hmp_hostfwd_remove,
      },
 diff --git a/net/slirp.c b/net/slirp.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/slirp.c
 +++ b/net/slirp.c
@@ -XXX,XX +XXX,XX @@ error:
      return -1;
  }
 -static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
 -                                const char *stack)
 +static SlirpState *slirp_lookup(Monitor *mon, const char *hub_id,
 +                                const char *name)
  {
--    uint32_t tbd_array = le32_to_cpu(s->tx.tbd_array_addr);
+-
--    uint16_t tcb_bytes = (le16_to_cpu(s->tx.tcb_bytes) & 0x3fff);
+-    if (vlan) {
-+    uint32_t tbd_array = s->tx.tbd_array_addr;
++    if (name) {
-+    uint16_t tcb_bytes = s->tx.tcb_bytes & 0x3fff;
+         NetClientState *nc;
-     /* Sends larger than MAX_ETH_FRAME_SIZE are allowed, up to 2600 bytes. */
+-        nc = net_hub_find_client_by_name(strtol(vlan, NULL, 0), stack);
-     uint8_t buf[2600];
+-        if (!nc) {
-     uint16_t size = 0;
+-            monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
 -            return NULL;
 +        if (hub_id) {
 +            nc = net_hub_find_client_by_name(strtol(hub_id, NULL, 0), name);
 +            if (!nc) {
 +                monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
 +                return NULL;
 +            }
 +        } else {
 +            nc = qemu_find_netdev(name);
 +            if (!nc) {
 +                monitor_printf(mon, "unrecognized netdev id '%s'\n", name);
 +                return NULL;
 +            }
          }
          if (strcmp(nc->model, "user")) {
              monitor_printf(mon, "invalid device specified\n");
@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
      const char *arg2 = qdict_get_try_str(qdict, "arg2");
      const char *arg3 = qdict_get_try_str(qdict, "arg3");
 -    if (arg2) {
 +    if (arg3) {
          s = slirp_lookup(mon, arg1, arg2);
          src_str = arg3;
 +    } else if (arg2) {
 +        s = slirp_lookup(mon, NULL, arg1);
 +        src_str = arg2;
      } else {
          s = slirp_lookup(mon, NULL, NULL);
          src_str = arg1;
@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_add(Monitor *mon, const QDict *qdict)
      const char *arg2 = qdict_get_try_str(qdict, "arg2");
      const char *arg3 = qdict_get_try_str(qdict, "arg3");
 -    if (arg2) {
 +    if (arg3) {
          s = slirp_lookup(mon, arg1, arg2);
          redir_str = arg3;
 +    } else if (arg2) {
 +        s = slirp_lookup(mon, NULL, arg1);
 +        redir_str = arg2;
      } else {
          s = slirp_lookup(mon, NULL, NULL);
          redir_str = arg1;
 --
 .7.4

-[Qemu-devel] [PULL 2/6] Revert "Add new PCI ID for i82559a"
+[Qemu-devel] [PULL 5/6] qemu-doc: Get rid of "vlan=X" example in the documentation
-This reverts commit 5e89dc01133f8f5e621f6b66b356c6f37d31dafb since:
+From: Thomas Huth <thuth@redhat.com>
-- we should use ID in the spec instead the one used by OEM
+The vlan concept is marked as deprecated, so we should not use
-- in the future, we should allow changing id through either property
+this for examples in the documentation anymore.
   or EEPROM file.
-Cc: Stefan Weil <sw@weilnetz.de>
+Signed-off-by: Thomas Huth <thuth@redhat.com>
 Cc: Michael Nawrocki <michael.nawrocki@gtri.gatech.edu>
 Cc: Peter Maydell <peter.maydell@linaro.org>
 Cc: Michael S. Tsirkin <mst@redhat.com>
 Reviewed-by: Stefan Weil <sw@weilnetz.de>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/eepro100.c    | 13 -------------
+ qemu-options.hx | 4 ++--
- include/hw/compat.h  |  4 ----
+file changed, 2 insertions(+), 2 deletions(-)
  include/hw/pci/pci.h |  1 -
  qemu-options.hx      |  2 +-
 files changed, 1 insertion(+), 19 deletions(-)
-diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/net/eepro100.c
-+++ b/hw/net/eepro100.c
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-     const char *name;
-     const char *desc;
-     uint16_t device_id;
--    uint16_t alt_device_id;
-     uint8_t revision;
-     uint16_t subsystem_vendor_id;
-     uint16_t subsystem_id;
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-     /* Quasi static device properties (no need to save them). */
-     uint16_t stats_size;
-     bool has_extended_tcb_support;
--    bool use_alt_device_id;
- } EEPRO100State;
- /* Word indices in EEPROM. */
-@@ -XXX,XX +XXX,XX @@ static void e100_nic_realize(PCIDevice *pci_dev, Error **errp)
-     TRACE(OTHER, logout("\n"));
--    /* By default, the i82559a adapter uses the legacy PCI ID (for the
--     * i82557). This allows the PCI ID to be changed to the alternate
--     * i82559 ID if needed.
--     */
--    if (s->use_alt_device_id && strcmp(info->name, "i82559a") == 0) {
--        pci_config_set_device_id(s->dev.config, info->alt_device_id);
--    }
--
-     s->device = info->device;
-     e100_pci_reset(s, &local_err);
-@@ -XXX,XX +XXX,XX @@ static E100PCIDeviceInfo e100_devices[] = {
-         .desc = "Intel i82559A Ethernet",
-         .device = i82559A,
-         .device_id = PCI_DEVICE_ID_INTEL_82557,
--        .alt_device_id = PCI_DEVICE_ID_INTEL_82559,
-         .revision = 0x06,
-         .stats_size = 80,
-         .has_extended_tcb_support = true,
-@@ -XXX,XX +XXX,XX @@ static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s)
- static Property e100_properties[] = {
-     DEFINE_NIC_PROPERTIES(EEPRO100State, conf),
--    DEFINE_PROP_BOOL("x-use-alt-device-id", EEPRO100State, use_alt_device_id,
--                     true),
-     DEFINE_PROP_END_OF_LIST(),
- };
-diff --git a/include/hw/compat.h b/include/hw/compat.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/compat.h
-+++ b/include/hw/compat.h
-@@ -XXX,XX +XXX,XX @@
-         .driver   = "virtio-tablet-device",\
-         .property = "wheel-axis",\
-         .value    = "false",\
--    },{\
--        .driver   = "i82559a",\
--        .property = "x-use-alt-device-id",\
--        .value    = "false",\
-     },
- #define HW_COMPAT_2_9 \
-diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/pci/pci.h
-+++ b/include/hw/pci/pci.h
-@@ -XXX,XX +XXX,XX @@ extern bool pci_available;
- /* Intel (0x8086) */
- #define PCI_DEVICE_ID_INTEL_82551IT      0x1209
- #define PCI_DEVICE_ID_INTEL_82557        0x1229
--#define PCI_DEVICE_ID_INTEL_82559        0x1030
- #define PCI_DEVICE_ID_INTEL_82801IR      0x2922
- /* Red Hat / Qumranet (for QEMU) -- see pci-ids.txt */
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
-@@ -XXX,XX +XXX,XX @@ that the card should have; this option currently only affects virtio cards; set
+@@ -XXX,XX +XXX,XX @@ qemu-system-i386 linux.img -net nic -net tap
- @var{v} = 0 to disable MSI-X. If no @option{-net} option is specified, a single
+ #launch a QEMU instance with two NICs, each one connected
- NIC is created.  QEMU can emulate several different models of network card.
+ #to a TAP device
- Valid values for @var{type} are
+ qemu-system-i386 linux.img \
--@code{virtio}, @code{i82551}, @code{i82557b}, @code{i82559a}, @code{i82559er},
+-                 -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \
-+@code{virtio}, @code{i82551}, @code{i82557b}, @code{i82559er},
+-                 -net nic,vlan=1 -net tap,vlan=1,ifname=tap1
- @code{ne2k_pci}, @code{ne2k_isa}, @code{pcnet}, @code{rtl8139},
++        -netdev tap,id=nd0,ifname=tap0 -device e1000,netdev=nd0 \
- @code{e1000}, @code{smc91c111}, @code{lance} and @code{mcf_fec}.
++        -netdev tap,id=nd1,ifname=tap1 -device rtl8139,netdev=nd1
- Not all devices are supported on all targets.  Use @code{-net nic,model=help}
+ @end example
  @example
 --
 .7.4

-[Qemu-devel] [PULL 4/6] MAINTAINERS: Add missing entry for eepro100 emulation
+[Qemu-devel] [PULL 6/6] MAINTAINERS: update Dmitry Fleytman email
-From: Stefan Weil <sw@weilnetz.de>
+From: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Signed-off-by: Stefan Weil <sw@weilnetz.de>
+gently asked by his automatic reply :)
 Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- MAINTAINERS | 5 +++++
+ MAINTAINERS | 8 ++++----
-file changed, 5 insertions(+)
+file changed, 4 insertions(+), 4 deletions(-)
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ M: Dmitry Fleytman <dmitry@daynix.com>
+@@ -XXX,XX +XXX,XX @@ F: hw/scsi/mfi.h
  F: tests/megasas-test.c
  Network packet abstractions
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: include/net/eth.h
  F: net/eth.c
@@ -XXX,XX +XXX,XX @@ F: hw/net/net_rx_pkt*
  F: hw/net/net_tx_pkt*
  Vmware
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: hw/net/vmxnet*
  F: hw/scsi/vmw_pvscsi*
@@ -XXX,XX +XXX,XX @@ F: hw/mem/nvdimm.c
  F: include/hw/mem/nvdimm.h
  e1000x
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: hw/net/e1000x*
  e1000e
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: hw/net/e1000e*
-+eepro100
-+M: Stefan Weil <sw@weilnetz.de>
-+S: Maintained
-+F: hw/net/eepro100.c
-+
- Generic Loader
- M: Alistair Francis <alistair.francis@xilinx.com>
- S: Maintained
 --
 .7.4

The following changes since commit 2e02083438962d26ef9dcc7100f3b378104183db:

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (2017-11-17 19:08:07 +0000)

are available in the git repository at:

https://github.com/jasowang/qemu.git tags/net-pull-request

for you to fetch changes up to c527e0afcd7d719abc3a5ca5e4c8ac2fe48b999f:

hw/net/vmxnet3: Fix code to work on big endian hosts, too (2017-11-20 11:08:00 +0800)

----------------------------------------------------------------

----------------------------------------------------------------
Ed Swierk (1):
      net: Transmit zero UDP checksum as 0xFFFF

Jason Wang (1):
      Revert "Add new PCI ID for i82559a"

Mao Zhongyi (1):
      colo-compare: fix the dangerous assignment

Stefan Weil (1):
      MAINTAINERS: Add missing entry for eepro100 emulation

Thomas Huth (2):
      hw/net/eepro100: Fix endianness problem on big endian hosts
      hw/net/vmxnet3: Fix code to work on big endian hosts, too

This reverts commit 5e89dc01133f8f5e621f6b66b356c6f37d31dafb since:

- we should use ID in the spec instead the one used by OEM
- in the future, we should allow changing id through either property
  or EEPROM file.

Cc: Stefan Weil <sw@weilnetz.de>
Cc: Michael Nawrocki <michael.nawrocki@gtri.gatech.edu>
Cc: Peter Maydell <peter.maydell@linaro.org>
Cc: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/eepro100.c    | 13 -------------
 include/hw/compat.h  |  4 ----
 include/hw/pci/pci.h |  1 -
 qemu-options.hx      |  2 +-
 4 files changed, 1 insertion(+), 19 deletions(-)

diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/eepro100.c
+++ b/hw/net/eepro100.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
     const char *name;
     const char *desc;
     uint16_t device_id;
-    uint16_t alt_device_id;
     uint8_t revision;
     uint16_t subsystem_vendor_id;
     uint16_t subsystem_id;
@@ -XXX,XX +XXX,XX @@ typedef struct {
     /* Quasi static device properties (no need to save them). */
     uint16_t stats_size;
     bool has_extended_tcb_support;
-    bool use_alt_device_id;
 } EEPRO100State;
 
 /* Word indices in EEPROM. */
@@ -XXX,XX +XXX,XX @@ static void e100_nic_realize(PCIDevice *pci_dev, Error **errp)
 
     TRACE(OTHER, logout("\n"));
 
-    /* By default, the i82559a adapter uses the legacy PCI ID (for the
-     * i82557). This allows the PCI ID to be changed to the alternate
-     * i82559 ID if needed.
-     */
-    if (s->use_alt_device_id && strcmp(info->name, "i82559a") == 0) {
-        pci_config_set_device_id(s->dev.config, info->alt_device_id);
-    }
-
     s->device = info->device;
 
     e100_pci_reset(s, &local_err);
@@ -XXX,XX +XXX,XX @@ static E100PCIDeviceInfo e100_devices[] = {
         .desc = "Intel i82559A Ethernet",
         .device = i82559A,
         .device_id = PCI_DEVICE_ID_INTEL_82557,
-        .alt_device_id = PCI_DEVICE_ID_INTEL_82559,
         .revision = 0x06,
         .stats_size = 80,
         .has_extended_tcb_support = true,
@@ -XXX,XX +XXX,XX @@ static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s)
 
 static Property e100_properties[] = {
     DEFINE_NIC_PROPERTIES(EEPRO100State, conf),
-    DEFINE_PROP_BOOL("x-use-alt-device-id", EEPRO100State, use_alt_device_id,
-                     true),
     DEFINE_PROP_END_OF_LIST(),
 };
 
diff --git a/include/hw/compat.h b/include/hw/compat.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/compat.h
+++ b/include/hw/compat.h
@@ -XXX,XX +XXX,XX @@
         .driver   = "virtio-tablet-device",\
         .property = "wheel-axis",\
         .value    = "false",\
-    },{\
-        .driver   = "i82559a",\
-        .property = "x-use-alt-device-id",\
-        .value    = "false",\
     },
 
 #define HW_COMPAT_2_9 \
diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/pci/pci.h
+++ b/include/hw/pci/pci.h
@@ -XXX,XX +XXX,XX @@ extern bool pci_available;
 /* Intel (0x8086) */
 #define PCI_DEVICE_ID_INTEL_82551IT      0x1209
 #define PCI_DEVICE_ID_INTEL_82557        0x1229
-#define PCI_DEVICE_ID_INTEL_82559        0x1030
 #define PCI_DEVICE_ID_INTEL_82801IR      0x2922
 
 /* Red Hat / Qumranet (for QEMU) -- see pci-ids.txt */
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ that the card should have; this option currently only affects virtio cards; set
 @var{v} = 0 to disable MSI-X. If no @option{-net} option is specified, a single
 NIC is created.  QEMU can emulate several different models of network card.
 Valid values for @var{type} are
-@code{virtio}, @code{i82551}, @code{i82557b}, @code{i82559a}, @code{i82559er},
+@code{virtio}, @code{i82551}, @code{i82557b}, @code{i82559er},
 @code{ne2k_pci}, @code{ne2k_isa}, @code{pcnet}, @code{rtl8139},
 @code{e1000}, @code{smc91c111}, @code{lance} and @code{mcf_fec}.
 Not all devices are supported on all targets.  Use @code{-net nic,model=help}
-- 
2.7.4

From: Thomas Huth <thuth@redhat.com>

Since commit 1865e288a823c764cd4344d ("Fix eepro100 simple transmission
mode"), the test/pxe-test is broken for the eepro100 device on big
endian hosts. However, it seems like that commit did not introduce the
problem, but just uncovered it: The EEPRO100State->tx.tbd_array_addr and
EEPRO100State->tx.tcb_bytes fields are already in host byte order, since
they have already been byte-swapped in the read_cb() function.
Thus byte-swapping them in tx_command() again results in the wrong
endianness. Removing the byte-swapping here fixes the pxe-test.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/eepro100.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/eepro100.c
+++ b/hw/net/eepro100.c
@@ -XXX,XX +XXX,XX @@ static void read_cb(EEPRO100State *s)
 
 static void tx_command(EEPRO100State *s)
 {
-    uint32_t tbd_array = le32_to_cpu(s->tx.tbd_array_addr);
-    uint16_t tcb_bytes = (le16_to_cpu(s->tx.tcb_bytes) & 0x3fff);
+    uint32_t tbd_array = s->tx.tbd_array_addr;
+    uint16_t tcb_bytes = s->tx.tcb_bytes & 0x3fff;
     /* Sends larger than MAX_ETH_FRAME_SIZE are allowed, up to 2600 bytes. */
     uint8_t buf[2600];
     uint16_t size = 0;
-- 
2.7.4

From: Ed Swierk <eswierk@skyportsystems.com>

The checksum algorithm used by IPv4, TCP and UDP allows a zero value
to be represented by either 0x0000 and 0xFFFF. But per RFC 768, a zero
UDP checksum must be transmitted as 0xFFFF because 0x0000 is a special
value meaning no checksum.

Substitute 0xFFFF whenever a checksum is computed as zero when
modifying a UDP datagram header. Doing this on IPv4 and TCP checksums
is unnecessary but legal. Add a wrapper for net_checksum_finish() that
makes the substitution.

(We can't just change net_checksum_finish(), as that function is also
used by receivers to verify checksums, and in that case the expected
value is always 0x0000.)

Signed-off-by: Ed Swierk <eswierk@skyportsystems.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000.c         | 2 +-
 hw/net/net_rx_pkt.c    | 2 +-
 hw/net/net_tx_pkt.c    | 2 +-
 hw/net/vmxnet3.c       | 3 ++-
 include/net/checksum.h | 6 ++++++
 5 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/hw/net/e1000.c b/hw/net/e1000.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000.c
+++ b/hw/net/e1000.c
@@ -XXX,XX +XXX,XX @@ putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
         n = cse + 1;
     if (sloc < n-1) {
         sum = net_checksum_add(n-css, data+css);
-        stw_be_p(data + sloc, net_checksum_finish(sum));
+        stw_be_p(data + sloc, net_checksum_finish_nozero(sum));
     }
 }
 
diff --git a/hw/net/net_rx_pkt.c b/hw/net/net_rx_pkt.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/net_rx_pkt.c
+++ b/hw/net/net_rx_pkt.c
@@ -XXX,XX +XXX,XX @@ _net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
     cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
                                  pkt->l4hdr_off, csl, cso);
 
-    csum = net_checksum_finish(cntr);
+    csum = net_checksum_finish_nozero(cntr);
 
     trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);
 
diff --git a/hw/net/net_tx_pkt.c b/hw/net/net_tx_pkt.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/net_tx_pkt.c
+++ b/hw/net/net_tx_pkt.c
@@ -XXX,XX +XXX,XX @@ static void net_tx_pkt_do_sw_csum(struct NetTxPkt *pkt)
         net_checksum_add_iov(iov, iov_len, pkt->virt_hdr.csum_start, csl, cso);
 
     /* Put the checksum obtained into the packet */
-    csum = cpu_to_be16(net_checksum_finish(csum_cntr));
+    csum = cpu_to_be16(net_checksum_finish_nozero(csum_cntr));
     iov_from_buf(iov, iov_len, csum_offset, &csum, sizeof csum);
 }
 
diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/vmxnet3.c
+++ b/hw/net/vmxnet3.c
@@ -XXX,XX +XXX,XX @@ static void vmxnet3_rx_need_csum_calculate(struct NetRxPkt *pkt,
     data = (uint8_t *)pkt_data + vhdr->csum_start;
     len = pkt_len - vhdr->csum_start;
     /* Put the checksum obtained into the packet */
-    stw_be_p(data + vhdr->csum_offset, net_raw_checksum(data, len));
+    stw_be_p(data + vhdr->csum_offset,
+             net_checksum_finish_nozero(net_checksum_add(len, data)));
 
     vhdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
     vhdr->flags |= VIRTIO_NET_HDR_F_DATA_VALID;
diff --git a/include/net/checksum.h b/include/net/checksum.h
index XXXXXXX..XXXXXXX 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -XXX,XX +XXX,XX @@ net_checksum_add(int len, uint8_t *buf)
 }
 
 static inline uint16_t
+net_checksum_finish_nozero(uint32_t sum)
+{
+    return net_checksum_finish(sum) ?: 0xFFFF;
+}
+
+static inline uint16_t
 net_raw_checksum(uint8_t *data, int length)
 {
     return net_checksum_finish(net_checksum_add(length, data));
-- 
2.7.4

From: Thomas Huth <thuth@redhat.com>

Since commit ab06ec43577177a442e8 we test the vmxnet3 device in the
pxe-tester, too (when running "make check SPEED=slow"). This now
revealed that the code is not working there if the host is a big
endian machine (for example ppc64 or s390x) - "make check SPEED=slow"
is now failing on such hosts.

The vmxnet3 code lacks endianness conversions in a couple of places.
Interestingly, the bitfields in the structs in vmxnet3.h already tried to
take care of the *bit* endianness of the C compilers - but the code missed
to change the *byte* endianness when reading or writing the corresponding
structs. So the bitfields are now wrapped into unions which allow to change
the byte endianness during runtime with the non-bitfield member of the union.
With these changes, "make check SPEED=slow" now properly works on big endian
hosts, too.

Reported-by: David Gibson <dgibson@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: David Gibson <dgibson@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/vmware_utils.h |   6 ++
 hw/net/vmxnet3.c      |  46 +++++++---
 hw/net/vmxnet3.h      | 230 ++++++++++++++++++++++++++++++--------------------
 3 files changed, 181 insertions(+), 101 deletions(-)

diff --git a/hw/net/vmware_utils.h b/hw/net/vmware_utils.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/vmware_utils.h
+++ b/hw/net/vmware_utils.h
@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld16(PCIDevice *d, hwaddr addr)
 {
     uint16_t res;
     pci_dma_read(d, addr, &res, 2);
+    res = le16_to_cpu(res);
     VMW_SHPRN("SHMEM load16: %" PRIx64 " (value 0x%X)", addr, res);
     return res;
 }
@@ -XXX,XX +XXX,XX @@ static inline void
 vmw_shmem_st16(PCIDevice *d, hwaddr addr, uint16_t value)
 {
     VMW_SHPRN("SHMEM store16: %" PRIx64 " (value 0x%X)", addr, value);
+    value = cpu_to_le16(value);
     pci_dma_write(d, addr, &value, 2);
 }
 
@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld32(PCIDevice *d, hwaddr addr)
 {
     uint32_t res;
     pci_dma_read(d, addr, &res, 4);
+    res = le32_to_cpu(res);
     VMW_SHPRN("SHMEM load32: %" PRIx64 " (value 0x%X)", addr, res);
     return res;
 }
@@ -XXX,XX +XXX,XX @@ static inline void
 vmw_shmem_st32(PCIDevice *d, hwaddr addr, uint32_t value)
 {
     VMW_SHPRN("SHMEM store32: %" PRIx64 " (value 0x%X)", addr, value);
+    value = cpu_to_le32(value);
     pci_dma_write(d, addr, &value, 4);
 }
 
@@ -XXX,XX +XXX,XX @@ vmw_shmem_ld64(PCIDevice *d, hwaddr addr)
 {
     uint64_t res;
     pci_dma_read(d, addr, &res, 8);
+    res = le64_to_cpu(res);
     VMW_SHPRN("SHMEM load64: %" PRIx64 " (value %" PRIx64 ")", addr, res);
     return res;
 }
@@ -XXX,XX +XXX,XX @@ static inline void
 vmw_shmem_st64(PCIDevice *d, hwaddr addr, uint64_t value)
 {
     VMW_SHPRN("SHMEM store64: %" PRIx64 " (value %" PRIx64 ")", addr, value);
+    value = cpu_to_le64(value);
     pci_dma_write(d, addr, &value, 8);
 }
 
diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/vmxnet3.c
+++ b/hw/net/vmxnet3.c
@@ -XXX,XX +XXX,XX @@ vmxnet3_dump_tx_descr(struct Vmxnet3_TxDesc *descr)
               "addr %" PRIx64 ", len: %d, gen: %d, rsvd: %d, "
               "dtype: %d, ext1: %d, msscof: %d, hlen: %d, om: %d, "
               "eop: %d, cq: %d, ext2: %d, ti: %d, tci: %d",
-              le64_to_cpu(descr->addr), descr->len, descr->gen, descr->rsvd,
+              descr->addr, descr->len, descr->gen, descr->rsvd,
               descr->dtype, descr->ext1, descr->msscof, descr->hlen, descr->om,
               descr->eop, descr->cq, descr->ext2, descr->ti, descr->tci);
 }
@@ -XXX,XX +XXX,XX @@ vmxnet3_dump_rx_descr(struct Vmxnet3_RxDesc *descr)
 {
     VMW_PKPRN("RX DESCR: addr %" PRIx64 ", len: %d, gen: %d, rsvd: %d, "
               "dtype: %d, ext1: %d, btype: %d",
-              le64_to_cpu(descr->addr), descr->len, descr->gen,
+              descr->addr, descr->len, descr->gen,
               descr->rsvd, descr->dtype, descr->ext1, descr->btype);
 }
 
@@ -XXX,XX +XXX,XX @@ static void vmxnet3_complete_packet(VMXNET3State *s, int qidx, uint32_t tx_ridx)
     memset(&txcq_descr, 0, sizeof(txcq_descr));
     txcq_descr.txdIdx = tx_ridx;
     txcq_descr.gen = vmxnet3_ring_curr_gen(&s->txq_descr[qidx].comp_ring);
-
+    txcq_descr.val1 = cpu_to_le32(txcq_descr.val1);
+    txcq_descr.val2 = cpu_to_le32(txcq_descr.val2);
     vmxnet3_ring_write_curr_cell(d, &s->txq_descr[qidx].comp_ring, &txcq_descr);
 
     /* Flush changes in TX descriptor before changing the counter value */
@@ -XXX,XX +XXX,XX @@ vmxnet3_on_rx_done_update_stats(VMXNET3State *s,
     }
 }
 
+static inline void
+vmxnet3_ring_read_curr_txdesc(PCIDevice *pcidev, Vmxnet3Ring *ring,
+                              struct Vmxnet3_TxDesc *txd)
+{
+    vmxnet3_ring_read_curr_cell(pcidev, ring, txd);
+    txd->addr = le64_to_cpu(txd->addr);
+    txd->val1 = le32_to_cpu(txd->val1);
+    txd->val2 = le32_to_cpu(txd->val2);
+}
+
 static inline bool
 vmxnet3_pop_next_tx_descr(VMXNET3State *s,
                           int qidx,
@@ -XXX,XX +XXX,XX @@ vmxnet3_pop_next_tx_descr(VMXNET3State *s,
     Vmxnet3Ring *ring = &s->txq_descr[qidx].tx_ring;
     PCIDevice *d = PCI_DEVICE(s);
 
-    vmxnet3_ring_read_curr_cell(d, ring, txd);
+    vmxnet3_ring_read_curr_txdesc(d, ring, txd);
     if (txd->gen == vmxnet3_ring_curr_gen(ring)) {
         /* Only read after generation field verification */
         smp_rmb();
         /* Re-read to be sure we got the latest version */
-        vmxnet3_ring_read_curr_cell(d, ring, txd);
+        vmxnet3_ring_read_curr_txdesc(d, ring, txd);
         VMXNET3_RING_DUMP(VMW_RIPRN, "TX", qidx, ring);
         *descr_idx = vmxnet3_ring_curr_cell_idx(ring);
         vmxnet3_inc_tx_consumption_counter(s, qidx);
@@ -XXX,XX +XXX,XX @@ static void vmxnet3_process_tx_queue(VMXNET3State *s, int qidx)
 
         if (!s->skip_current_tx_pkt) {
             data_len = (txd.len > 0) ? txd.len : VMXNET3_MAX_TX_BUF_SIZE;
-            data_pa = le64_to_cpu(txd.addr);
+            data_pa = txd.addr;
 
             if (!net_tx_pkt_add_raw_fragment(s->tx_pkt,
                                                 data_pa,
@@ -XXX,XX +XXX,XX @@ vmxnet3_read_next_rx_descr(VMXNET3State *s, int qidx, int ridx,
     Vmxnet3Ring *ring = &s->rxq_descr[qidx].rx_ring[ridx];
     *didx = vmxnet3_ring_curr_cell_idx(ring);
     vmxnet3_ring_read_curr_cell(d, ring, dbuf);
+    dbuf->addr = le64_to_cpu(dbuf->addr);
+    dbuf->val1 = le32_to_cpu(dbuf->val1);
+    dbuf->ext1 = le32_to_cpu(dbuf->ext1);
 }
 
 static inline uint8_t
@@ -XXX,XX +XXX,XX @@ vmxnet3_pop_rxc_descr(VMXNET3State *s, int qidx, uint32_t *descr_gen)
 
     pci_dma_read(PCI_DEVICE(s),
                  daddr, &rxcd, sizeof(struct Vmxnet3_RxCompDesc));
+    rxcd.val1 = le32_to_cpu(rxcd.val1);
+    rxcd.val2 = le32_to_cpu(rxcd.val2);
+    rxcd.val3 = le32_to_cpu(rxcd.val3);
     ring_gen = vmxnet3_ring_curr_gen(&s->rxq_descr[qidx].comp_ring);
 
     if (rxcd.gen != ring_gen) {
@@ -XXX,XX +XXX,XX @@ vmxnet3_pci_dma_writev(PCIDevice *pci_dev,
     }
 }
 
+static void
+vmxnet3_pci_dma_write_rxcd(PCIDevice *pcidev, dma_addr_t pa,
+                           struct Vmxnet3_RxCompDesc *rxcd)
+{
+    rxcd->val1 = cpu_to_le32(rxcd->val1);
+    rxcd->val2 = cpu_to_le32(rxcd->val2);
+    rxcd->val3 = cpu_to_le32(rxcd->val3);
+    pci_dma_write(pcidev, pa, rxcd, sizeof(*rxcd));
+}
+
 static bool
 vmxnet3_indicate_packet(VMXNET3State *s)
 {
@@ -XXX,XX +XXX,XX @@ vmxnet3_indicate_packet(VMXNET3State *s)
         }
 
         chunk_size = MIN(bytes_left, rxd.len);
-        vmxnet3_pci_dma_writev(d, data, bytes_copied,
-                               le64_to_cpu(rxd.addr), chunk_size);
+        vmxnet3_pci_dma_writev(d, data, bytes_copied, rxd.addr, chunk_size);
         bytes_copied += chunk_size;
         bytes_left -= chunk_size;
 
         vmxnet3_dump_rx_descr(&rxd);
 
         if (ready_rxcd_pa != 0) {
-            pci_dma_write(d, ready_rxcd_pa, &rxcd, sizeof(rxcd));
+            vmxnet3_pci_dma_write_rxcd(d, ready_rxcd_pa, &rxcd);
         }
 
         memset(&rxcd, 0, sizeof(struct Vmxnet3_RxCompDesc));
@@ -XXX,XX +XXX,XX @@ vmxnet3_indicate_packet(VMXNET3State *s)
         rxcd.eop = 1;
         rxcd.err = (bytes_left != 0);
 
-        pci_dma_write(d, ready_rxcd_pa, &rxcd, sizeof(rxcd));
+        vmxnet3_pci_dma_write_rxcd(d, ready_rxcd_pa, &rxcd);
 
         /* Flush RX descriptor changes */
         smp_wmb();
diff --git a/hw/net/vmxnet3.h b/hw/net/vmxnet3.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/vmxnet3.h
+++ b/hw/net/vmxnet3.h
@@ -XXX,XX +XXX,XX @@ enum {
 struct Vmxnet3_TxDesc {
     __le64 addr;
 
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32 msscof:14;  /* MSS, checksum offset, flags */
-    u32 ext1:1;
-    u32 dtype:1;    /* descriptor type */
-    u32 rsvd:1;
-    u32 gen:1;      /* generation bit */
-    u32 len:14;
+            u32 msscof:14;  /* MSS, checksum offset, flags */
+            u32 ext1:1;
+            u32 dtype:1;    /* descriptor type */
+            u32 rsvd:1;
+            u32 gen:1;      /* generation bit */
+            u32 len:14;
 #else
-    u32 len:14;
-    u32 gen:1;      /* generation bit */
-    u32 rsvd:1;
-    u32 dtype:1;    /* descriptor type */
-    u32 ext1:1;
-    u32 msscof:14;  /* MSS, checksum offset, flags */
+            u32 len:14;
+            u32 gen:1;      /* generation bit */
+            u32 rsvd:1;
+            u32 dtype:1;    /* descriptor type */
+            u32 ext1:1;
+            u32 msscof:14;  /* MSS, checksum offset, flags */
 #endif  /* __BIG_ENDIAN_BITFIELD */
-
+        };
+        u32 val1;
+    };
+    
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32 tci:16;     /* Tag to Insert */
-    u32 ti:1;       /* VLAN Tag Insertion */
-    u32 ext2:1;
-    u32 cq:1;       /* completion request */
-    u32 eop:1;      /* End Of Packet */
-    u32 om:2;       /* offload mode */
-    u32 hlen:10;    /* header len */
+            u32 tci:16;     /* Tag to Insert */
+            u32 ti:1;       /* VLAN Tag Insertion */
+            u32 ext2:1;
+            u32 cq:1;       /* completion request */
+            u32 eop:1;      /* End Of Packet */
+            u32 om:2;       /* offload mode */
+            u32 hlen:10;    /* header len */
 #else
-    u32 hlen:10;    /* header len */
-    u32 om:2;       /* offload mode */
-    u32 eop:1;      /* End Of Packet */
-    u32 cq:1;       /* completion request */
-    u32 ext2:1;
-    u32 ti:1;       /* VLAN Tag Insertion */
-    u32 tci:16;     /* Tag to Insert */
+            u32 hlen:10;    /* header len */
+            u32 om:2;       /* offload mode */
+            u32 eop:1;      /* End Of Packet */
+            u32 cq:1;       /* completion request */
+            u32 ext2:1;
+            u32 ti:1;       /* VLAN Tag Insertion */
+            u32 tci:16;     /* Tag to Insert */
 #endif  /* __BIG_ENDIAN_BITFIELD */
+        };
+        u32 val2;
+    };
 };
 
 /* TxDesc.OM values */
@@ -XXX,XX +XXX,XX @@ struct Vmxnet3_TxDataDesc {
 #define VMXNET3_TCD_GEN_DWORD_SHIFT    3
 
 struct Vmxnet3_TxCompDesc {
-    u32        txdIdx:12;    /* Index of the EOP TxDesc */
-    u32        ext1:20;
-
+    union {
+        struct {
+#ifdef __BIG_ENDIAN_BITFIELD
+            u32 ext1:20;
+            u32 txdIdx:12;    /* Index of the EOP TxDesc */
+#else
+            u32 txdIdx:12;    /* Index of the EOP TxDesc */
+            u32 ext1:20;
+#endif
+        };
+        u32 val1;
+    };
     __le32        ext2;
     __le32        ext3;
 
-    u32        rsvd:24;
-    u32        type:7;       /* completion type */
-    u32        gen:1;        /* generation bit */
+    union {
+        struct {
+#ifdef __BIG_ENDIAN_BITFIELD
+            u32 gen:1;        /* generation bit */
+            u32 type:7;       /* completion type */
+            u32 rsvd:24;
+#else
+            u32 rsvd:24;
+            u32 type:7;       /* completion type */
+            u32 gen:1;        /* generation bit */
+#endif
+        };
+        u32 val2;
+    };
 };
 
 struct Vmxnet3_RxDesc {
     __le64        addr;
-
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32        gen:1;        /* Generation bit */
-    u32        rsvd:15;
-    u32        dtype:1;      /* Descriptor type */
-    u32        btype:1;      /* Buffer Type */
-    u32        len:14;
+            u32 gen:1;        /* Generation bit */
+            u32 rsvd:15;
+            u32 dtype:1;      /* Descriptor type */
+            u32 btype:1;      /* Buffer Type */
+            u32 len:14;
 #else
-    u32        len:14;
-    u32        btype:1;      /* Buffer Type */
-    u32        dtype:1;      /* Descriptor type */
-    u32        rsvd:15;
-    u32        gen:1;        /* Generation bit */
+            u32 len:14;
+            u32 btype:1;      /* Buffer Type */
+            u32 dtype:1;      /* Descriptor type */
+            u32 rsvd:15;
+            u32 gen:1;        /* Generation bit */
 #endif
+        };
+        u32 val1;
+    };
     u32        ext1;
 };
 
@@ -XXX,XX +XXX,XX @@ struct Vmxnet3_RxDesc {
 #define VMXNET3_RXD_GEN_SHIFT    31
 
 struct Vmxnet3_RxCompDesc {
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32        ext2:1;
-    u32        cnc:1;        /* Checksum Not Calculated */
-    u32        rssType:4;    /* RSS hash type used */
-    u32        rqID:10;      /* rx queue/ring ID */
-    u32        sop:1;        /* Start of Packet */
-    u32        eop:1;        /* End of Packet */
-    u32        ext1:2;
-    u32        rxdIdx:12;    /* Index of the RxDesc */
+            u32 ext2:1;
+            u32 cnc:1;        /* Checksum Not Calculated */
+            u32 rssType:4;    /* RSS hash type used */
+            u32 rqID:10;      /* rx queue/ring ID */
+            u32 sop:1;        /* Start of Packet */
+            u32 eop:1;        /* End of Packet */
+            u32 ext1:2;
+            u32 rxdIdx:12;    /* Index of the RxDesc */
 #else
-    u32        rxdIdx:12;    /* Index of the RxDesc */
-    u32        ext1:2;
-    u32        eop:1;        /* End of Packet */
-    u32        sop:1;        /* Start of Packet */
-    u32        rqID:10;      /* rx queue/ring ID */
-    u32        rssType:4;    /* RSS hash type used */
-    u32        cnc:1;        /* Checksum Not Calculated */
-    u32        ext2:1;
+            u32 rxdIdx:12;    /* Index of the RxDesc */
+            u32 ext1:2;
+            u32 eop:1;        /* End of Packet */
+            u32 sop:1;        /* Start of Packet */
+            u32 rqID:10;      /* rx queue/ring ID */
+            u32 rssType:4;    /* RSS hash type used */
+            u32 cnc:1;        /* Checksum Not Calculated */
+            u32 ext2:1;
 #endif  /* __BIG_ENDIAN_BITFIELD */
+        };
+        u32 val1;
+    };
 
     __le32        rssHash;      /* RSS hash value */
 
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32        tci:16;       /* Tag stripped */
-    u32        ts:1;         /* Tag is stripped */
-    u32        err:1;        /* Error */
-    u32        len:14;       /* data length */
+            u32 tci:16;       /* Tag stripped */
+            u32 ts:1;         /* Tag is stripped */
+            u32 err:1;        /* Error */
+            u32 len:14;       /* data length */
 #else
-    u32        len:14;       /* data length */
-    u32        err:1;        /* Error */
-    u32        ts:1;         /* Tag is stripped */
-    u32        tci:16;       /* Tag stripped */
+            u32 len:14;       /* data length */
+            u32 err:1;        /* Error */
+            u32 ts:1;         /* Tag is stripped */
+            u32 tci:16;       /* Tag stripped */
 #endif  /* __BIG_ENDIAN_BITFIELD */
+        };
+        u32 val2;
+    };
 
-
+    union {
+        struct {
 #ifdef __BIG_ENDIAN_BITFIELD
-    u32        gen:1;        /* generation bit */
-    u32        type:7;       /* completion type */
-    u32        fcs:1;        /* Frame CRC correct */
-    u32        frg:1;        /* IP Fragment */
-    u32        v4:1;         /* IPv4 */
-    u32        v6:1;         /* IPv6 */
-    u32        ipc:1;        /* IP Checksum Correct */
-    u32        tcp:1;        /* TCP packet */
-    u32        udp:1;        /* UDP packet */
-    u32        tuc:1;        /* TCP/UDP Checksum Correct */
-    u32        csum:16;
+            u32 gen:1;        /* generation bit */
+            u32 type:7;       /* completion type */
+            u32 fcs:1;        /* Frame CRC correct */
+            u32 frg:1;        /* IP Fragment */
+            u32 v4:1;         /* IPv4 */
+            u32 v6:1;         /* IPv6 */
+            u32 ipc:1;        /* IP Checksum Correct */
+            u32 tcp:1;        /* TCP packet */
+            u32 udp:1;        /* UDP packet */
+            u32 tuc:1;        /* TCP/UDP Checksum Correct */
+            u32 csum:16;
 #else
-    u32        csum:16;
-    u32        tuc:1;        /* TCP/UDP Checksum Correct */
-    u32        udp:1;        /* UDP packet */
-    u32        tcp:1;        /* TCP packet */
-    u32        ipc:1;        /* IP Checksum Correct */
-    u32        v6:1;         /* IPv6 */
-    u32        v4:1;         /* IPv4 */
-    u32        frg:1;        /* IP Fragment */
-    u32        fcs:1;        /* Frame CRC correct */
-    u32        type:7;       /* completion type */
-    u32        gen:1;        /* generation bit */
+            u32 csum:16;
+            u32 tuc:1;        /* TCP/UDP Checksum Correct */
+            u32 udp:1;        /* UDP packet */
+            u32 tcp:1;        /* TCP packet */
+            u32 ipc:1;        /* IP Checksum Correct */
+            u32 v6:1;         /* IPv6 */
+            u32 v4:1;         /* IPv4 */
+            u32 frg:1;        /* IP Fragment */
+            u32 fcs:1;        /* Frame CRC correct */
+            u32 type:7;       /* completion type */
+            u32 gen:1;        /* generation bit */
 #endif  /* __BIG_ENDIAN_BITFIELD */
+        };
+        u32 val3;
+    };
 };
 
 /* fields in RxCompDesc we access via Vmxnet3_GenericDesc.dword[3] */
-- 
2.7.4

The following changes since commit e607bbee553cfe73072870cef458cfa4e78133e2:

Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-01-26.for-upstream' into staging (2018-01-26 14:24:25 +0000)

are available in the git repository at:

https://github.com/jasowang/qemu.git tags/net-pull-request

for you to fetch changes up to bf4835a4d5338bb7424827715df22570a8adc67c:

MAINTAINERS: update Dmitry Fleytman email (2018-01-29 16:05:38 +0800)

----------------------------------------------------------------

----------------------------------------------------------------
Mao Zhongyi (2):
      colo: modified the payload compare function
      colo: compare the packet based on the tcp sequence number

Philippe Mathieu-Daudé (1):
      MAINTAINERS: update Dmitry Fleytman email

Thomas Huth (3):
      net: Allow hubports to connect to other netdevs
      net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove'
      qemu-doc: Get rid of "vlan=X" example in the documentation

From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>

Modified the function colo_packet_compare_common to prepare for the
tcp packet comparison in the next patch.

Cc: Zhang Chen <zhangckid@gmail.com>
Cc: Li Zhijian <lizhijian@cn.fujitsu.com>
Cc: Jason Wang <jasowang@redhat.com>

Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Signed-off-by: Zhang Chen <zhangckid@gmail.com>
Reviewed-by: Zhang Chen <zhangckid@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 88 +++++++++++++++++++++++++++---------------------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/net/colo-compare.c b/net/colo-compare.c
index XXXXXXX..XXXXXXX 100644
--- a/net/colo-compare.c
+++ b/net/colo-compare.c
@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
  * return:    0  means packet same
  *            > 0 || < 0 means packet different
  */
-static int colo_packet_compare_common(Packet *ppkt,
-                                      Packet *spkt,
-                                      int poffset,
-                                      int soffset)
+static int colo_compare_packet_payload(Packet *ppkt,
+                                       Packet *spkt,
+                                       uint16_t poffset,
+                                       uint16_t soffset,
+                                       uint16_t len)
+
 {
     if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
         char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_common(Packet *ppkt,
                                    sec_ip_src, sec_ip_dst);
     }
 
-    poffset = ppkt->vnet_hdr_len + poffset;
-    soffset = ppkt->vnet_hdr_len + soffset;
-
-    if (ppkt->size - poffset == spkt->size - soffset) {
-        return memcmp(ppkt->data + poffset,
-                      spkt->data + soffset,
-                      spkt->size - soffset);
-    } else {
-        trace_colo_compare_main("Net packet size are not the same");
-        return -1;
-    }
+    return memcmp(ppkt->data + poffset, spkt->data + soffset, len);
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
      * the secondary guest's timestamp. COLO just focus on payload,
      * so we just need skip this field.
      */
-    if (ptcp->th_off > 5) {
-        ptrdiff_t ptcp_offset, stcp_offset;
 
-        ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
-                      + (ptcp->th_off * 4) - ppkt->vnet_hdr_len;
-        stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
-                      + (stcp->th_off * 4) - spkt->vnet_hdr_len;
+    ptrdiff_t ptcp_offset, stcp_offset;
 
-        /*
-         * When network is busy, some tcp options(like sack) will unpredictable
-         * occur in primary side or secondary side. it will make packet size
-         * not same, but the two packet's payload is identical. colo just
-         * care about packet payload, so we skip the option field.
-         */
-        res = colo_packet_compare_common(ppkt, spkt, ptcp_offset, stcp_offset);
-    } else if (ptcp->th_sum == stcp->th_sum) {
-        res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN, ETH_HLEN);
+    ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
+                  + (ptcp->th_off << 2) - ppkt->vnet_hdr_len;
+    stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
+                  + (stcp->th_off << 2) - spkt->vnet_hdr_len;
+    if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) {
+        res = colo_compare_packet_payload(ppkt, spkt,
+                                          ptcp_offset, stcp_offset,
+                                          ppkt->size - ptcp_offset);
     } else {
+        trace_colo_compare_main("TCP: payload size of packets are different");
         res = -1;
     }
 
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
  */
 static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
 {
-    int ret;
-    int network_header_length = ppkt->ip->ip_hl * 4;
+    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
+    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
 
     trace_colo_compare_main("compare udp");
 
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
      * other field like TOS,TTL,IP Checksum. we only need to compare
      * the ip payload here.
      */
-    ret = colo_packet_compare_common(ppkt, spkt,
-                                     network_header_length + ETH_HLEN,
-                                     network_header_length + ETH_HLEN);
-
-    if (ret) {
+    if (ppkt->size != spkt->size) {
+        trace_colo_compare_main("UDP: payload size of packets are different");
+        return -1;
+    }
+    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
+                                    ppkt->size - offset)) {
         trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size);
         trace_colo_compare_udp_miscompare("Secondary pkt size", spkt->size);
         if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
             qemu_hexdump((char *)spkt->data, stderr, "colo-compare sec pkt",
                          spkt->size);
         }
+        return -1;
+    } else {
+        return 0;
     }
-
-    return ret;
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
  */
 static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
 {
-    int network_header_length = ppkt->ip->ip_hl * 4;
+    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
+    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
 
     trace_colo_compare_main("compare icmp");
 
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
      * other field like TOS,TTL,IP Checksum. we only need to compare
      * the ip payload here.
      */
-    if (colo_packet_compare_common(ppkt, spkt,
-                                   network_header_length + ETH_HLEN,
-                                   network_header_length + ETH_HLEN)) {
+    if (ppkt->size != spkt->size) {
+        trace_colo_compare_main("ICMP: payload size of packets are different");
+        return -1;
+    }
+    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
+                                    ppkt->size - offset)) {
         trace_colo_compare_icmp_miscompare("primary pkt size",
                                            ppkt->size);
         trace_colo_compare_icmp_miscompare("Secondary pkt size",
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
  */
 static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
 {
+    uint16_t offset = ppkt->vnet_hdr_len;
+
     trace_colo_compare_main("compare other");
     if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
         char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
                                    sec_ip_src, sec_ip_dst);
     }
 
-    return colo_packet_compare_common(ppkt, spkt, 0, 0);
+    if (ppkt->size != spkt->size) {
+        trace_colo_compare_main("Other: payload size of packets are different");
+        return -1;
+    }
+    return colo_compare_packet_payload(ppkt, spkt, offset, offset,
+                                       ppkt->size - offset);
 }
 
 static int colo_old_packet_check_one(Packet *pkt, int64_t *check_time)
-- 
2.7.4

From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>

Packet size some time different or when network is busy.
Based on same payload size, but TCP protocol can not
guarantee send the same one packet in the same way,

like that:
We send this payload:
------------------------------
| header |1|2|3|4|5|6|7|8|9|0|
------------------------------

primary:
ppkt1:
----------------
| header |1|2|3|
----------------
ppkt2:
------------------------
| header |4|5|6|7|8|9|0|
------------------------

secondary:
spkt1:
------------------------------
| header |1|2|3|4|5|6|7|8|9|0|
------------------------------

In the original method, ppkt1 and ppkt2 are different in size and
spkt1, so they can't compare and trigger the checkpoint.

I have tested FTP get 200M and 1G file many times, I found that
the performance was less than 1% of the native.

Now I reconstructed the comparison of TCP packets based on the
TCP sequence number. first of all, ppkt1 and spkt1 have the same
starting sequence number, so they can compare, even though their
length is different. And then ppkt1 with a smaller payload length
is used as the comparison length, if the payload is same, send
out the ppkt1 and record the offset(the length of ppkt1 payload)
in spkt1. The next comparison, ppkt2 and spkt1 can be compared
from the recorded position of spkt1.

like that:
----------------
| header |1|2|3| ppkt1
---------|-----|
         |     |
---------v-----v--------------
| header |1|2|3|4|5|6|7|8|9|0| spkt1
---------------|\------------|
               | \offset     |
      ---------v-------------v
      | header |4|5|6|7|8|9|0| ppkt2
      ------------------------

In this way, the performance can reach native 20% in my multiple
tests.

Cc: Zhang Chen <zhangckid@gmail.com>
Cc: Li Zhijian <lizhijian@cn.fujitsu.com>
Cc: Jason Wang <jasowang@redhat.com>

Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
Signed-off-by: Zhang Chen <zhangckid@gmail.com>
Reviewed-by: Zhang Chen <zhangckid@gmail.com>
Tested-by: Zhang Chen <zhangckid@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 343 +++++++++++++++++++++++++++++++++++------------------
 net/colo.c         |   9 ++
 net/colo.h         |  15 +++
 net/trace-events   |   2 +-
 4 files changed, 250 insertions(+), 119 deletions(-)

diff --git a/net/colo-compare.c b/net/colo-compare.c
index XXXXXXX..XXXXXXX 100644
--- a/net/colo-compare.c
+++ b/net/colo-compare.c
@@ -XXX,XX +XXX,XX @@
 #define COMPARE_READ_LEN_MAX NET_BUFSIZE
 #define MAX_QUEUE_SIZE 1024
 
+#define COLO_COMPARE_FREE_PRIMARY     0x01
+#define COLO_COMPARE_FREE_SECONDARY   0x02
+
 /* TODO: Should be configurable */
 #define REGULAR_PACKET_CHECK_MS 3000
 
@@ -XXX,XX +XXX,XX @@ static gint seq_sorter(Packet *a, Packet *b, gpointer data)
     return ntohl(atcp->th_seq) - ntohl(btcp->th_seq);
 }
 
+static void fill_pkt_tcp_info(void *data, uint32_t *max_ack)
+{
+    Packet *pkt = data;
+    struct tcphdr *tcphd;
+
+    tcphd = (struct tcphdr *)pkt->transport_header;
+
+    pkt->tcp_seq = ntohl(tcphd->th_seq);
+    pkt->tcp_ack = ntohl(tcphd->th_ack);
+    *max_ack = *max_ack > pkt->tcp_ack ? *max_ack : pkt->tcp_ack;
+    pkt->header_size = pkt->transport_header - (uint8_t *)pkt->data
+                       + (tcphd->th_off << 2) - pkt->vnet_hdr_len;
+    pkt->payload_size = pkt->size - pkt->header_size;
+    pkt->seq_end = pkt->tcp_seq + pkt->payload_size;
+    pkt->flags = tcphd->th_flags;
+}
+
 /*
  * Return 1 on success, if return 0 means the
  * packet will be dropped
  */
-static int colo_insert_packet(GQueue *queue, Packet *pkt)
+static int colo_insert_packet(GQueue *queue, Packet *pkt, uint32_t *max_ack)
 {
     if (g_queue_get_length(queue) <= MAX_QUEUE_SIZE) {
         if (pkt->ip->ip_p == IPPROTO_TCP) {
+            fill_pkt_tcp_info(pkt, max_ack);
             g_queue_insert_sorted(queue,
                                   pkt,
                                   (GCompareDataFunc)seq_sorter,
@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
     }
 
     if (mode == PRIMARY_IN) {
-        if (!colo_insert_packet(&conn->primary_list, pkt)) {
+        if (!colo_insert_packet(&conn->primary_list, pkt, &conn->pack)) {
             error_report("colo compare primary queue size too big,"
                          "drop packet");
         }
     } else {
-        if (!colo_insert_packet(&conn->secondary_list, pkt)) {
+        if (!colo_insert_packet(&conn->secondary_list, pkt, &conn->sack)) {
             error_report("colo compare secondary queue size too big,"
                          "drop packet");
         }
@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
     return 0;
 }
 
+static inline bool after(uint32_t seq1, uint32_t seq2)
+{
+        return (int32_t)(seq1 - seq2) > 0;
+}
+
+static void colo_release_primary_pkt(CompareState *s, Packet *pkt)
+{
+    int ret;
+    ret = compare_chr_send(s,
+                           pkt->data,
+                           pkt->size,
+                           pkt->vnet_hdr_len);
+    if (ret < 0) {
+        error_report("colo send primary packet failed");
+    }
+    trace_colo_compare_main("packet same and release packet");
+    packet_destroy(pkt, NULL);
+}
+
 /*
  * The IP packets sent by primary and secondary
  * will be compared in here
@@ -XXX,XX +XXX,XX @@ static int colo_compare_packet_payload(Packet *ppkt,
 }
 
 /*
- * Called from the compare thread on the primary
- * for compare tcp packet
- * compare_tcp copied from Dr. David Alan Gilbert's branch
- */
-static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
+ * return true means that the payload is consist and
+ * need to make the next comparison, false means do
+ * the checkpoint
+*/
+static bool colo_mark_tcp_pkt(Packet *ppkt, Packet *spkt,
+                              int8_t *mark, uint32_t max_ack)
 {
-    struct tcphdr *ptcp, *stcp;
-    int res;
+    *mark = 0;
+
+    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
+        if (colo_compare_packet_payload(ppkt, spkt,
+                                        ppkt->header_size, spkt->header_size,
+                                        ppkt->payload_size)) {
+            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
+            return true;
+        }
+    }
+    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
+        if (colo_compare_packet_payload(ppkt, spkt,
+                                        ppkt->header_size, spkt->header_size,
+                                        ppkt->payload_size)) {
+            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
+            return true;
+        }
+    }
+
+    /* one part of secondary packet payload still need to be compared */
+    if (!after(ppkt->seq_end, spkt->seq_end)) {
+        if (colo_compare_packet_payload(ppkt, spkt,
+                                        ppkt->header_size + ppkt->offset,
+                                        spkt->header_size + spkt->offset,
+                                        ppkt->payload_size - ppkt->offset)) {
+            if (!after(ppkt->tcp_ack, max_ack)) {
+                *mark = COLO_COMPARE_FREE_PRIMARY;
+                spkt->offset += ppkt->payload_size - ppkt->offset;
+                return true;
+            } else {
+                /* secondary guest hasn't ack the data, don't send
+                 * out this packet
+                 */
+                return false;
+            }
+        }
+    } else {
+        /* primary packet is longer than secondary packet, compare
+         * the same part and mark the primary packet offset
+         */
+        if (colo_compare_packet_payload(ppkt, spkt,
+                                        ppkt->header_size + ppkt->offset,
+                                        spkt->header_size + spkt->offset,
+                                        spkt->payload_size - spkt->offset)) {
+            *mark = COLO_COMPARE_FREE_SECONDARY;
+            ppkt->offset += spkt->payload_size - spkt->offset;
+            return true;
+        }
+    }
 
-    trace_colo_compare_main("compare tcp");
+    return false;
+}
 
-    ptcp = (struct tcphdr *)ppkt->transport_header;
-    stcp = (struct tcphdr *)spkt->transport_header;
+static void colo_compare_tcp(CompareState *s, Connection *conn)
+{
+    Packet *ppkt = NULL, *spkt = NULL;
+    int8_t mark;
 
     /*
-     * The 'identification' field in the IP header is *very* random
-     * it almost never matches.  Fudge this by ignoring differences in
-     * unfragmented packets; they'll normally sort themselves out if different
-     * anyway, and it should recover at the TCP level.
-     * An alternative would be to get both the primary and secondary to rewrite
-     * somehow; but that would need some sync traffic to sync the state
-     */
-    if (ntohs(ppkt->ip->ip_off) & IP_DF) {
-        spkt->ip->ip_id = ppkt->ip->ip_id;
-        /* and the sum will be different if the IDs were different */
-        spkt->ip->ip_sum = ppkt->ip->ip_sum;
+     * If ppkt and spkt have the same payload, but ppkt's ACK
+     * is greater than spkt's ACK, in this case we can not
+     * send the ppkt because it will cause the secondary guest
+     * to miss sending some data in the next. Therefore, we
+     * record the maximum ACK in the current queue at both
+     * primary side and secondary side. Only when the ack is
+     * less than the smaller of the two maximum ack, then we
+     * can ensure that the packet's payload is acknowledged by
+     * primary and secondary.
+    */
+    uint32_t min_ack = conn->pack > conn->sack ? conn->sack : conn->pack;
+
+pri:
+    if (g_queue_is_empty(&conn->primary_list)) {
+        return;
     }
+    ppkt = g_queue_pop_head(&conn->primary_list);
+sec:
+    if (g_queue_is_empty(&conn->secondary_list)) {
+        g_queue_push_head(&conn->primary_list, ppkt);
+        return;
+    }
+    spkt = g_queue_pop_head(&conn->secondary_list);
 
-    /*
-     * Check tcp header length for tcp option field.
-     * th_off > 5 means this tcp packet have options field.
-     * The tcp options maybe always different.
-     * for example:
-     * From RFC 7323.
-     * TCP Timestamps option (TSopt):
-     * Kind: 8
-     *
-     * Length: 10 bytes
-     *
-     *    +-------+-------+---------------------+---------------------+
-     *    |Kind=8 |  10   |   TS Value (TSval)  |TS Echo Reply (TSecr)|
-     *    +-------+-------+---------------------+---------------------+
-     *       1       1              4                     4
-     *
-     * In this case the primary guest's timestamp always different with
-     * the secondary guest's timestamp. COLO just focus on payload,
-     * so we just need skip this field.
-     */
+    if (ppkt->tcp_seq == ppkt->seq_end) {
+        colo_release_primary_pkt(s, ppkt);
+        ppkt = NULL;
+    }
 
-    ptrdiff_t ptcp_offset, stcp_offset;
+    if (ppkt && conn->compare_seq && !after(ppkt->seq_end, conn->compare_seq)) {
+        trace_colo_compare_main("pri: this packet has compared");
+        colo_release_primary_pkt(s, ppkt);
+        ppkt = NULL;
+    }
 
-    ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
-                  + (ptcp->th_off << 2) - ppkt->vnet_hdr_len;
-    stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
-                  + (stcp->th_off << 2) - spkt->vnet_hdr_len;
-    if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) {
-        res = colo_compare_packet_payload(ppkt, spkt,
-                                          ptcp_offset, stcp_offset,
-                                          ppkt->size - ptcp_offset);
+    if (spkt->tcp_seq == spkt->seq_end) {
+        packet_destroy(spkt, NULL);
+        if (!ppkt) {
+            goto pri;
+        } else {
+            goto sec;
+        }
     } else {
-        trace_colo_compare_main("TCP: payload size of packets are different");
-        res = -1;
+        if (conn->compare_seq && !after(spkt->seq_end, conn->compare_seq)) {
+            trace_colo_compare_main("sec: this packet has compared");
+            packet_destroy(spkt, NULL);
+            if (!ppkt) {
+                goto pri;
+            } else {
+                goto sec;
+            }
+        }
+        if (!ppkt) {
+            g_queue_push_head(&conn->secondary_list, spkt);
+            goto pri;
+        }
     }
 
-    if (res != 0 &&
-        trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
-        char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
-
-        strcpy(pri_ip_src, inet_ntoa(ppkt->ip->ip_src));
-        strcpy(pri_ip_dst, inet_ntoa(ppkt->ip->ip_dst));
-        strcpy(sec_ip_src, inet_ntoa(spkt->ip->ip_src));
-        strcpy(sec_ip_dst, inet_ntoa(spkt->ip->ip_dst));
-
-        trace_colo_compare_ip_info(ppkt->size, pri_ip_src,
-                                   pri_ip_dst, spkt->size,
-                                   sec_ip_src, sec_ip_dst);
-
-        trace_colo_compare_tcp_info("pri tcp packet",
-                                    ntohl(ptcp->th_seq),
-                                    ntohl(ptcp->th_ack),
-                                    res, ptcp->th_flags,
-                                    ppkt->size);
-
-        trace_colo_compare_tcp_info("sec tcp packet",
-                                    ntohl(stcp->th_seq),
-                                    ntohl(stcp->th_ack),
-                                    res, stcp->th_flags,
-                                    spkt->size);
+    if (colo_mark_tcp_pkt(ppkt, spkt, &mark, min_ack)) {
+        trace_colo_compare_tcp_info("pri",
+                                    ppkt->tcp_seq, ppkt->tcp_ack,
+                                    ppkt->header_size, ppkt->payload_size,
+                                    ppkt->offset, ppkt->flags);
+
+        trace_colo_compare_tcp_info("sec",
+                                    spkt->tcp_seq, spkt->tcp_ack,
+                                    spkt->header_size, spkt->payload_size,
+                                    spkt->offset, spkt->flags);
+
+        if (mark == COLO_COMPARE_FREE_PRIMARY) {
+            conn->compare_seq = ppkt->seq_end;
+            colo_release_primary_pkt(s, ppkt);
+            g_queue_push_head(&conn->secondary_list, spkt);
+            goto pri;
+        }
+        if (mark == COLO_COMPARE_FREE_SECONDARY) {
+            conn->compare_seq = spkt->seq_end;
+            packet_destroy(spkt, NULL);
+            goto sec;
+        }
+        if (mark == (COLO_COMPARE_FREE_PRIMARY | COLO_COMPARE_FREE_SECONDARY)) {
+            conn->compare_seq = ppkt->seq_end;
+            colo_release_primary_pkt(s, ppkt);
+            packet_destroy(spkt, NULL);
+            goto pri;
+        }
+    } else {
+        g_queue_push_head(&conn->primary_list, ppkt);
+        g_queue_push_head(&conn->secondary_list, spkt);
 
         qemu_hexdump((char *)ppkt->data, stderr,
                      "colo-compare ppkt", ppkt->size);
         qemu_hexdump((char *)spkt->data, stderr,
                      "colo-compare spkt", spkt->size);
-    }
 
-    return res;
+        /*
+         * colo_compare_inconsistent_notify();
+         * TODO: notice to checkpoint();
+         */
+    }
 }
 
+
 /*
  * Called from the compare thread on the primary
  * for compare udp packet
@@ -XXX,XX +XXX,XX @@ static void colo_old_packet_check(void *opaque)
                         (GCompareFunc)colo_old_packet_check_one_conn);
 }
 
-/*
- * Called from the compare thread on the primary
- * for compare packet with secondary list of the
- * specified connection when a new packet was
- * queued to it.
- */
-static void colo_compare_connection(void *opaque, void *user_data)
+static void colo_compare_packet(CompareState *s, Connection *conn,
+                                int (*HandlePacket)(Packet *spkt,
+                                Packet *ppkt))
 {
-    CompareState *s = user_data;
-    Connection *conn = opaque;
     Packet *pkt = NULL;
     GList *result = NULL;
-    int ret;
 
     while (!g_queue_is_empty(&conn->primary_list) &&
            !g_queue_is_empty(&conn->secondary_list)) {
         pkt = g_queue_pop_head(&conn->primary_list);
-        switch (conn->ip_proto) {
-        case IPPROTO_TCP:
-            result = g_queue_find_custom(&conn->secondary_list,
-                     pkt, (GCompareFunc)colo_packet_compare_tcp);
-            break;
-        case IPPROTO_UDP:
-            result = g_queue_find_custom(&conn->secondary_list,
-                     pkt, (GCompareFunc)colo_packet_compare_udp);
-            break;
-        case IPPROTO_ICMP:
-            result = g_queue_find_custom(&conn->secondary_list,
-                     pkt, (GCompareFunc)colo_packet_compare_icmp);
-            break;
-        default:
-            result = g_queue_find_custom(&conn->secondary_list,
-                     pkt, (GCompareFunc)colo_packet_compare_other);
-            break;
-        }
+        result = g_queue_find_custom(&conn->secondary_list,
+                 pkt, (GCompareFunc)HandlePacket);
 
         if (result) {
-            ret = compare_chr_send(s,
-                                   pkt->data,
-                                   pkt->size,
-                                   pkt->vnet_hdr_len);
-            if (ret < 0) {
-                error_report("colo_send_primary_packet failed");
-            }
-            trace_colo_compare_main("packet same and release packet");
+            colo_release_primary_pkt(s, pkt);
             g_queue_remove(&conn->secondary_list, result->data);
-            packet_destroy(pkt, NULL);
         } else {
             /*
              * If one packet arrive late, the secondary_list or
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
     }
 }
 
+/*
+ * Called from the compare thread on the primary
+ * for compare packet with secondary list of the
+ * specified connection when a new packet was
+ * queued to it.
+ */
+static void colo_compare_connection(void *opaque, void *user_data)
+{
+    CompareState *s = user_data;
+    Connection *conn = opaque;
+
+    switch (conn->ip_proto) {
+    case IPPROTO_TCP:
+        colo_compare_tcp(s, conn);
+        break;
+    case IPPROTO_UDP:
+        colo_compare_packet(s, conn, colo_packet_compare_udp);
+        break;
+    case IPPROTO_ICMP:
+        colo_compare_packet(s, conn, colo_packet_compare_icmp);
+        break;
+    default:
+        colo_compare_packet(s, conn, colo_packet_compare_other);
+        break;
+    }
+}
+
 static int compare_chr_send(CompareState *s,
                             const uint8_t *buf,
                             uint32_t size,
diff --git a/net/colo.c b/net/colo.c
index XXXXXXX..XXXXXXX 100644
--- a/net/colo.c
+++ b/net/colo.c
@@ -XXX,XX +XXX,XX @@ Connection *connection_new(ConnectionKey *key)
     conn->processing = false;
     conn->offset = 0;
     conn->syn_flag = 0;
+    conn->pack = 0;
+    conn->sack = 0;
     g_queue_init(&conn->primary_list);
     g_queue_init(&conn->secondary_list);
 
@@ -XXX,XX +XXX,XX @@ Packet *packet_new(const void *data, int size, int vnet_hdr_len)
     pkt->size = size;
     pkt->creation_ms = qemu_clock_get_ms(QEMU_CLOCK_HOST);
     pkt->vnet_hdr_len = vnet_hdr_len;
+    pkt->tcp_seq = 0;
+    pkt->tcp_ack = 0;
+    pkt->seq_end = 0;
+    pkt->header_size = 0;
+    pkt->payload_size = 0;
+    pkt->offset = 0;
+    pkt->flags = 0;
 
     return pkt;
 }
diff --git a/net/colo.h b/net/colo.h
index XXXXXXX..XXXXXXX 100644
--- a/net/colo.h
+++ b/net/colo.h
@@ -XXX,XX +XXX,XX @@ typedef struct Packet {
     int64_t creation_ms;
     /* Get vnet_hdr_len from filter */
     uint32_t vnet_hdr_len;
+    uint32_t tcp_seq; /* sequence number */
+    uint32_t tcp_ack; /* acknowledgement number */
+    /* the sequence number of the last byte of the packet */
+    uint32_t seq_end;
+    uint8_t header_size;  /* the header length */
+    uint16_t payload_size; /* the payload length */
+    /* record the payload offset(the length that has been compared) */
+    uint16_t offset;
+    uint8_t flags; /* Flags(aka Control bits) */
 } Packet;
 
 typedef struct ConnectionKey {
@@ -XXX,XX +XXX,XX @@ typedef struct Connection {
     /* flag to enqueue unprocessed_connections */
     bool processing;
     uint8_t ip_proto;
+    /* record the sequence number that has been compared */
+    uint32_t compare_seq;
+    /* the maximum of acknowledgement number in primary_list queue */
+    uint32_t pack;
+    /* the maximum of acknowledgement number in secondary_list queue */
+    uint32_t sack;
     /* offset = secondary_seq - primary_seq */
     tcp_seq  offset;
     /*
diff --git a/net/trace-events b/net/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/net/trace-events
+++ b/net/trace-events
@@ -XXX,XX +XXX,XX @@ colo_compare_icmp_miscompare(const char *sta, int size) ": %s = %d"
 colo_compare_ip_info(int psize, const char *sta, const char *stb, int ssize, const char *stc, const char *std) "ppkt size = %d, ip_src = %s, ip_dst = %s, spkt size = %d, ip_src = %s, ip_dst = %s"
 colo_old_packet_check_found(int64_t old_time) "%" PRId64
 colo_compare_miscompare(void) ""
-colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int res, uint32_t flag, int size) "side: %s seq/ack= %u/%u res= %d flags= 0x%x pkt_size: %d\n"
+colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int hdlen, int pdlen, int offset, int flags) "%s: seq/ack= %u/%u hdlen= %d pdlen= %d offset= %d flags=%d\n"
 
 # net/filter-rewriter.c
 colo_filter_rewriter_debug(void) ""
-- 
2.7.4

From: Thomas Huth <thuth@redhat.com>

QEMU can emulate hubs to connect NICs and netdevs. This is currently
primarily used for the mis-named 'vlan' feature of the networking
subsystem. Now the 'vlan' feature has been marked as deprecated, since
its name is rather confusing and the users often rather mis-configure
their network when trying to use it. But while the 'vlan' parameter
should be removed at one point in time, the basic idea of emulating
a hub in QEMU is still good: It's useful for bundling up the output of
multiple NICs into one single l2tp netdev for example.

Now to be able to use the hubport feature without 'vlan's, there is one
missing piece: The possibility to connect a hubport to a netdev, too.
This patch adds this possibility by introducing a new "netdev=..."
parameter to the hubports.

To bundle up the output of multiple NICs into one socket netdev, you can
now run QEMU with these parameters for example:

qemu-system-ppc64 ... -netdev socket,id=s1,connect=:11122 \
    -netdev hubport,hubid=1,id=h1,netdev=s1 \
    -netdev hubport,hubid=1,id=h2 -device e1000,netdev=h2 \
    -netdev hubport,hubid=1,id=h3 -device virtio-net-pci,netdev=h3

For using the socket netdev, you have got to start another QEMU as the
receiving side first, for example with network dumping enabled:

qemu-system-x86_64 -M isapc -netdev socket,id=s0,listen=:11122 \
    -device ne2k_isa,netdev=s0 \
    -object filter-dump,id=f1,netdev=s0,file=/tmp/dump.dat

After the ppc64 guest tried to boot from both NICs, you can see in the
dump file (using Wireshark, for example), that the output of both NICs
(the e1000 and the virtio-net-pci) has been successfully transfered
via the socket netdev in this case.

Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/hub.c       | 27 +++++++++++++++++++++------
 net/hub.h       |  3 ++-
 net/net.c       |  2 +-
 qapi/net.json   |  4 +++-
 qemu-options.hx |  8 +++++---
 5 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/net/hub.c b/net/hub.c
index XXXXXXX..XXXXXXX 100644
--- a/net/hub.c
+++ b/net/hub.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "qapi/error.h"
 #include "monitor/monitor.h"
 #include "net/net.h"
 #include "clients.h"
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_hub_port_info = {
     .cleanup = net_hub_port_cleanup,
 };
 
-static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
+static NetHubPort *net_hub_port_new(NetHub *hub, const char *name,
+                                    NetClientState *hubpeer)
 {
     NetClientState *nc;
     NetHubPort *port;
@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
         name = default_name;
     }
 
-    nc = qemu_new_net_client(&net_hub_port_info, NULL, "hub", name);
+    nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name);
     port = DO_UPCAST(NetHubPort, nc, nc);
     port->id = id;
     port->hub = hub;
@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
 
 /**
  * Create a port on a given hub
+ * @hub_id: Number of the hub
  * @name: Net client name or NULL for default name.
+ * @hubpeer: Peer to use (if "netdev=id" has been specified)
  *
  * If there is no existing hub with the given id then a new hub is created.
  */
-NetClientState *net_hub_add_port(int hub_id, const char *name)
+NetClientState *net_hub_add_port(int hub_id, const char *name,
+                                 NetClientState *hubpeer)
 {
     NetHub *hub;
     NetHubPort *port;
@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_add_port(int hub_id, const char *name)
         hub = net_hub_new(hub_id);
     }
 
-    port = net_hub_port_new(hub, name);
+    port = net_hub_port_new(hub, name, hubpeer);
     return &port->nc;
 }
 
@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id)
         }
     }
 
-    nc = net_hub_add_port(hub_id, NULL);
+    nc = net_hub_add_port(hub_id, NULL, NULL);
     return nc;
 }
 
@@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name,
                      NetClientState *peer, Error **errp)
 {
     const NetdevHubPortOptions *hubport;
+    NetClientState *hubpeer = NULL;
 
     assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT);
     assert(!peer);
     hubport = &netdev->u.hubport;
 
-    net_hub_add_port(hubport->hubid, name);
+    if (hubport->has_netdev) {
+        hubpeer = qemu_find_netdev(hubport->netdev);
+        if (!hubpeer) {
+            error_setg(errp, "netdev '%s' not found", hubport->netdev);
+            return -1;
+        }
+    }
+
+    net_hub_add_port(hubport->hubid, name, hubpeer);
+
     return 0;
 }
 
diff --git a/net/hub.h b/net/hub.h
index XXXXXXX..XXXXXXX 100644
--- a/net/hub.h
+++ b/net/hub.h
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu-common.h"
 
-NetClientState *net_hub_add_port(int hub_id, const char *name);
+NetClientState *net_hub_add_port(int hub_id, const char *name,
+                                 NetClientState *hubpeer);
 NetClientState *net_hub_find_client_by_name(int hub_id, const char *name);
 void net_hub_info(Monitor *mon);
 void net_hub_check_clients(void);
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp)
         /* Do not add to a vlan if it's a nic with a netdev= parameter. */
         if (netdev->type != NET_CLIENT_DRIVER_NIC ||
             !opts->u.nic.has_netdev) {
-            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL);
+            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL, NULL);
         }
 
         if (net->has_vlan && !vlan_warned) {
diff --git a/qapi/net.json b/qapi/net.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -XXX,XX +XXX,XX @@
 # Connect two or more net clients through a software hub.
 #
 # @hubid: hub identifier number
+# @netdev: used to connect hub to a netdev instead of a device (since 2.12)
 #
 # Since: 1.2
 ##
 { 'struct': 'NetdevHubPortOptions',
   'data': {
-    'hubid':     'int32' } }
+    'hubid':     'int32',
+    '*netdev':    'str' } }
 
 ##
 # @NetdevNetmapOptions:
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
 #endif
     "-netdev vhost-user,id=str,chardev=dev[,vhostforce=on|off]\n"
     "                configure a vhost-user network, backed by a chardev 'dev'\n"
-    "-netdev hubport,id=str,hubid=n\n"
+    "-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
     "                configure a hub port on QEMU VLAN 'n'\n", QEMU_ARCH_ALL)
 DEF("net", HAS_ARG, QEMU_OPTION_net,
     "-net nic[,vlan=n][,netdev=nd][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n"
@@ -XXX,XX +XXX,XX @@ vde_switch -F -sock /tmp/myswitch
 qemu-system-i386 linux.img -net nic -net vde,sock=/tmp/myswitch
 @end example
 
-@item -netdev hubport,id=@var{id},hubid=@var{hubid}
+@item -netdev hubport,id=@var{id},hubid=@var{hubid}[,netdev=@var{nd}]
 
 Create a hub port on QEMU "vlan" @var{hubid}.
 
 The hubport netdev lets you connect a NIC to a QEMU "vlan" instead of a single
 netdev.  @code{-net} and @code{-device} with parameter @option{vlan} create the
-required hub automatically.
+required hub automatically. Alternatively, you can also connect the hubport
+to another netdev with ID @var{nd} by using the @option{netdev=@var{nd}}
+option.
 
 @item -netdev vhost-user,chardev=@var{id}[,vhostforce=on|off][,queues=n]
 
-- 
2.7.4

From: Thomas Huth <thuth@redhat.com>

It does not make much sense to limit these commands to the legacy 'vlan'
concept only, they should work with the modern netdevs, too. So now
it is possible to use this command with one, two or three parameters.

With one parameter, the command installs a hostfwd rule on the default
"user" network:
    hostfwd_add tcp:...

With two parameters, the command installs a hostfwd rule on a netdev
(that's the new way of using this command):
    hostfwd_add netdev_id tcp:...

With three parameters, the command installs a rule on a 'vlan' (aka hub):
    hostfwd_add hub_id name tcp:...

Same applies to the hostfwd_remove command now.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hmp-commands.hx |  4 ++--
 net/slirp.c     | 33 +++++++++++++++++++++++----------
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/hmp-commands.hx b/hmp-commands.hx
index XXXXXXX..XXXXXXX 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
     {
         .name       = "hostfwd_add",
         .args_type  = "arg1:s,arg2:s?,arg3:s?",
-        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
+        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
         .help       = "redirect TCP or UDP connections from host to guest (requires -net user)",
         .cmd        = hmp_hostfwd_add,
     },
@@ -XXX,XX +XXX,XX @@ ETEXI
     {
         .name       = "hostfwd_remove",
         .args_type  = "arg1:s,arg2:s?,arg3:s?",
-        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport",
+        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport",
         .help       = "remove host-to-guest TCP or UDP redirection",
         .cmd        = hmp_hostfwd_remove,
     },
diff --git a/net/slirp.c b/net/slirp.c
index XXXXXXX..XXXXXXX 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -XXX,XX +XXX,XX @@ error:
     return -1;
 }
 
-static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
-                                const char *stack)
+static SlirpState *slirp_lookup(Monitor *mon, const char *hub_id,
+                                const char *name)
 {
-
-    if (vlan) {
+    if (name) {
         NetClientState *nc;
-        nc = net_hub_find_client_by_name(strtol(vlan, NULL, 0), stack);
-        if (!nc) {
-            monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
-            return NULL;
+        if (hub_id) {
+            nc = net_hub_find_client_by_name(strtol(hub_id, NULL, 0), name);
+            if (!nc) {
+                monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
+                return NULL;
+            }
+        } else {
+            nc = qemu_find_netdev(name);
+            if (!nc) {
+                monitor_printf(mon, "unrecognized netdev id '%s'\n", name);
+                return NULL;
+            }
         }
         if (strcmp(nc->model, "user")) {
             monitor_printf(mon, "invalid device specified\n");
@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
     const char *arg2 = qdict_get_try_str(qdict, "arg2");
     const char *arg3 = qdict_get_try_str(qdict, "arg3");
 
-    if (arg2) {
+    if (arg3) {
         s = slirp_lookup(mon, arg1, arg2);
         src_str = arg3;
+    } else if (arg2) {
+        s = slirp_lookup(mon, NULL, arg1);
+        src_str = arg2;
     } else {
         s = slirp_lookup(mon, NULL, NULL);
         src_str = arg1;
@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_add(Monitor *mon, const QDict *qdict)
     const char *arg2 = qdict_get_try_str(qdict, "arg2");
     const char *arg3 = qdict_get_try_str(qdict, "arg3");
 
-    if (arg2) {
+    if (arg3) {
         s = slirp_lookup(mon, arg1, arg2);
         redir_str = arg3;
+    } else if (arg2) {
+        s = slirp_lookup(mon, NULL, arg1);
+        redir_str = arg2;
     } else {
         s = slirp_lookup(mon, NULL, NULL);
         redir_str = arg1;
-- 
2.7.4

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

gently asked by his automatic reply :)

Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 MAINTAINERS | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/scsi/mfi.h
 F: tests/megasas-test.c
 
 Network packet abstractions
-M: Dmitry Fleytman <dmitry@daynix.com>
+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 S: Maintained
 F: include/net/eth.h
 F: net/eth.c
@@ -XXX,XX +XXX,XX @@ F: hw/net/net_rx_pkt*
 F: hw/net/net_tx_pkt*
 
 Vmware
-M: Dmitry Fleytman <dmitry@daynix.com>
+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 S: Maintained
 F: hw/net/vmxnet*
 F: hw/scsi/vmw_pvscsi*
@@ -XXX,XX +XXX,XX @@ F: hw/mem/nvdimm.c
 F: include/hw/mem/nvdimm.h
 
 e1000x
-M: Dmitry Fleytman <dmitry@daynix.com>
+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 S: Maintained
 F: hw/net/e1000x*
 
 e1000e
-M: Dmitry Fleytman <dmitry@daynix.com>
+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 S: Maintained
 F: hw/net/e1000e*
 
-- 
2.7.4