Series comparison

-[Qemu-devel] [PULL 00/14] Net patches
+[PULL 00/23] Net patches
-The following changes since commit 6632f6ff96f0537fc34cdc00c760656fc62e23c5:
+The following changes since commit e0175b71638cf4398903c0d25f93fe62e0606389:
-  Merge remote-tracking branch 'remotes/famz/tags/block-and-testing-pull-request' into staging (2017-07-17 11:46:36 +0100)
+  Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200228' into staging (2020-02-28 16:39:27 +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 189ae6bb5ce1f5a322f8691d00fe942ba43dd601:
+for you to fetch changes up to 41aa2e3f9b27fd259a13711545d933a20f1d2f16:
-  virtio-net: fix offload ctrl endian (2017-07-17 20:13:56 +0800)
+  l2tpv3: fix RFC number typo in qemu-options.hx (2020-03-02 15:30:08 +0800)
 ----------------------------------------------------------------
-- fix virtio-net ctrl offload endian
+----------------------------------------------------------------
-- vnet header support for variou COLO netfilters and compare thread
+Bin Meng (1):
       hw: net: cadence_gem: Fix build errors in DB_PRINT()
-----------------------------------------------------------------
+Finn Thain (14):
-Jason Wang (1):
+      dp8393x: Mask EOL bit from descriptor addresses
-      virtio-net: fix offload ctrl endian
+      dp8393x: Always use 32-bit accesses
       dp8393x: Clean up endianness hacks
       dp8393x: Have dp8393x_receive() return the packet size
       dp8393x: Update LLFA and CRDA registers from rx descriptor
       dp8393x: Clear RRRA command register bit only when appropriate
       dp8393x: Implement packet size limit and RBAE interrupt
       dp8393x: Don't clobber packet checksum
       dp8393x: Use long-word-aligned RRA pointers in 32-bit mode
       dp8393x: Pad frames to word or long word boundary
       dp8393x: Clear descriptor in_use field to release packet
       dp8393x: Always update RRA pointers and sequence numbers
       dp8393x: Don't reset Silicon Revision register
       dp8393x: Don't stop reception upon RBE interrupt assertion
-Michal Privoznik (1):
+Lukas Straub (4):
-      virtion-net: Prefer is_power_of_2()
+      block/replication.c: Ignore requests after failover
       tests/test-replication.c: Add test for for secondary node continuing replication
       net/filter.c: Add Options to insert filters anywhere in the filter list
       colo: Update Documentation for continuous replication
-Zhang Chen (12):
+Stefan Hajnoczi (1):
-      net: Add vnet_hdr_len arguments in NetClientState
+      l2tpv3: fix RFC number typo in qemu-options.hx
       net/net.c: Add vnet_hdr support in SocketReadState
       net/filter-mirror.c: Introduce parameter for filter_send()
       net/filter-mirror.c: Make filter mirror support vnet support.
       net/filter-mirror.c: Add new option to enable vnet support for filter-redirector
       net/colo.c: Make vnet_hdr_len as packet property
       net/colo-compare.c: Introduce parameter for compare_chr_send()
       net/colo-compare.c: Make colo-compare support vnet_hdr_len
       net/colo.c: Add vnet packet parse feature in colo-proxy
       net/colo-compare.c: Add vnet packet's tcp/udp/icmp compare
       net/filter-rewriter.c: Make filter-rewriter support vnet_hdr_len
       docs/colo-proxy.txt: Update colo-proxy usage of net driver with vnet_header
- docs/colo-proxy.txt   | 26 ++++++++++++++++
+Yuri Benditovich (3):
- hw/net/virtio-net.c   |  4 ++-
+      e1000e: Avoid hw_error if legacy mode used
- include/net/net.h     | 10 ++++--
+      NetRxPkt: Introduce support for additional hash types
- net/colo-compare.c    | 84 ++++++++++++++++++++++++++++++++++++++++++---------
+      NetRxPkt: fix hash calculation of IPV6 TCP
- net/colo.c            |  9 +++---
- net/colo.h            |  4 ++-
+ block/replication.c        |  35 ++++++-
- net/filter-mirror.c   | 75 +++++++++++++++++++++++++++++++++++++++++----
+ docs/COLO-FT.txt           | 224 +++++++++++++++++++++++++++++++++------------
- net/filter-rewriter.c | 37 ++++++++++++++++++++++-
+ docs/block-replication.txt |  28 ++++--
- net/net.c             | 37 ++++++++++++++++++++---
+ hw/net/cadence_gem.c       |  11 ++-
- net/socket.c          |  8 ++---
+ hw/net/dp8393x.c           | 200 ++++++++++++++++++++++++++--------------
- qemu-options.hx       | 19 ++++++------
+ hw/net/e1000e_core.c       |  15 +--
-files changed, 265 insertions(+), 48 deletions(-)
+ hw/net/net_rx_pkt.c        |  44 ++++++++-
  hw/net/net_rx_pkt.h        |   6 +-
  hw/net/trace-events        |   4 +
  include/net/filter.h       |   2 +
  net/filter.c               |  92 ++++++++++++++++++-
  qemu-options.hx            |  35 +++++--
  tests/test-replication.c   |  52 +++++++++++
 files changed, 591 insertions(+), 157 deletions(-)

-New patch
+[PULL 01/23] dp8393x: Mask EOL bit from descriptor addresses
+From: Finn Thain <fthain@telegraphics.com.au>
+The Least Significant bit of a descriptor address register is used as
+an EOL flag. It has to be masked when the register value is to be used
+as an actual address for copying memory around. But when the registers
+are to be updated the EOL bit should not be masked.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+---
+ hw/net/dp8393x.c | 17 +++++++++++------
+file changed, 11 insertions(+), 6 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ do { printf("sonic ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
+ #define SONIC_ISR_PINT   0x0800
+ #define SONIC_ISR_LCD    0x1000
++#define SONIC_DESC_EOL   0x0001
++#define SONIC_DESC_ADDR  0xFFFE
++
+ #define TYPE_DP8393X "dp8393x"
+ #define DP8393X(obj) OBJECT_CHECK(dp8393xState, (obj), TYPE_DP8393X)
+@@ -XXX,XX +XXX,XX @@ static uint32_t dp8393x_crba(dp8393xState *s)
+ static uint32_t dp8393x_crda(dp8393xState *s)
+ {
+-    return (s->regs[SONIC_URDA] << 16) | s->regs[SONIC_CRDA];
++    return (s->regs[SONIC_URDA] << 16) |
++           (s->regs[SONIC_CRDA] & SONIC_DESC_ADDR);
+ }
+ static uint32_t dp8393x_rbwc(dp8393xState *s)
+@@ -XXX,XX +XXX,XX @@ static uint32_t dp8393x_tsa(dp8393xState *s)
+ static uint32_t dp8393x_ttda(dp8393xState *s)
+ {
+-    return (s->regs[SONIC_UTDA] << 16) | s->regs[SONIC_TTDA];
++    return (s->regs[SONIC_UTDA] << 16) |
++           (s->regs[SONIC_TTDA] & SONIC_DESC_ADDR);
+ }
+ static uint32_t dp8393x_wt(dp8393xState *s)
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_transmit_packets(dp8393xState *s)
+                                MEMTXATTRS_UNSPECIFIED, s->data,
+                                size);
+             s->regs[SONIC_CTDA] = dp8393x_get(s, width, 0) & ~0x1;
+-            if (dp8393x_get(s, width, 0) & 0x1) {
++            if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
+                 /* EOL detected */
+                 break;
+             }
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+     /* XXX: Check byte ordering */
+     /* Check for EOL */
+-    if (s->regs[SONIC_LLFA] & 0x1) {
++    if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
+         /* Are we still in resource exhaustion? */
+         size = sizeof(uint16_t) * 1 * width;
+         address = dp8393x_crda(s) + sizeof(uint16_t) * 5 * width;
+         address_space_read(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                            s->data, size);
+-        if (dp8393x_get(s, width, 0) & 0x1) {
++        if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
+             /* Still EOL ; stop reception */
+             return -1;
+         } else {
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+                        dp8393x_crda(s) + sizeof(uint16_t) * 5 * width,
+                        MEMTXATTRS_UNSPECIFIED, s->data, size);
+     s->regs[SONIC_LLFA] = dp8393x_get(s, width, 0);
+-    if (s->regs[SONIC_LLFA] & 0x1) {
++    if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
+         /* EOL detected */
+         s->regs[SONIC_ISR] |= SONIC_ISR_RDE;
+     } else {
+--
+.5.0

-[Qemu-devel] [PULL 07/14] net/colo-compare.c: Introduce parameter for compare_chr_send()
+[PULL 02/23] dp8393x: Always use 32-bit accesses
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-This patch change the compare_chr_send() parameter from CharBackend to CompareState,
+The DP83932 and DP83934 have 32 data lines. The datasheet says,
 we can get more information like vnet_hdr(We use it to support packet with vnet_header).
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+    Data Bus: These bidirectional lines are used to transfer data on the
     system bus. When the SONIC is a bus master, 16-bit data is transferred
     on D15-D0 and 32-bit data is transferred on D31-D0. When the SONIC is
     accessed as a slave, register data is driven onto lines D15-D0.
     D31-D16 are held TRI-STATE if SONIC is in 16-bit mode. If SONIC is in
 -bit mode, they are driven, but invalid.
 Always use 32-bit accesses both as bus master and bus slave.
 Force the MSW to zero in bus master mode.
 This gets the Linux 'jazzsonic' driver working, and avoids the need for
 prior hacks to make the NetBSD 'sn' driver work.
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Tested-by: Laurent Vivier <laurent@vivier.eu>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 14 +++++++-------
+ hw/net/dp8393x.c | 47 +++++++++++++++++++++++++++++------------------
-file changed, 7 insertions(+), 7 deletions(-)
+file changed, 29 insertions(+), 18 deletions(-)
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/hw/net/dp8393x.c
-+++ b/net/colo-compare.c
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ enum {
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_put(dp8393xState *s, int width, int offset,
-     SECONDARY_IN,
+                         uint16_t val)
- };
+ {
+     if (s->big_endian) {
--static int compare_chr_send(CharBackend *out,
+-        s->data[offset * width + width - 1] = cpu_to_be16(val);
-+static int compare_chr_send(CompareState *s,
++        if (width == 2) {
-                             const uint8_t *buf,
++            s->data[offset * 2] = 0;
-                             uint32_t size);
++            s->data[offset * 2 + 1] = cpu_to_be16(val);
++        } else {
-@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
++            s->data[offset] = cpu_to_be16(val);
-         }
++        }
+     } else {
-         if (result) {
+-        s->data[offset * width] = cpu_to_le16(val);
--            ret = compare_chr_send(&s->chr_out, pkt->data, pkt->size);
++        if (width == 2) {
-+            ret = compare_chr_send(s, pkt->data, pkt->size);
++            s->data[offset * 2] = cpu_to_le16(val);
-             if (ret < 0) {
++            s->data[offset * 2 + 1] = 0;
-                 error_report("colo_send_primary_packet failed");
++        } else {
-             }
++            s->data[offset] = cpu_to_le16(val);
-@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
++        }
      }
  }
--static int compare_chr_send(CharBackend *out,
+@@ -XXX,XX +XXX,XX @@ static uint64_t dp8393x_read(void *opaque, hwaddr addr, unsigned int size)
-+static int compare_chr_send(CompareState *s,
-                             const uint8_t *buf,
+     DPRINTF("read 0x%04x from reg %s\n", val, reg_names[reg]);
-                             uint32_t size)
 -    return val;
 +    return s->big_endian ? val << 16 : val;
  }
  static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
  {
-@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CharBackend *out,
+     dp8393xState *s = opaque;
-         return 0;
+     int reg = addr >> s->it_shift;
 +    uint32_t val = s->big_endian ? data >> 16 : data;
 -    DPRINTF("write 0x%04x to reg %s\n", (uint16_t)data, reg_names[reg]);
 +    DPRINTF("write 0x%04x to reg %s\n", (uint16_t)val, reg_names[reg]);
      switch (reg) {
          /* Command register */
          case SONIC_CR:
 -            dp8393x_do_command(s, data);
 +            dp8393x_do_command(s, val);
              break;
          /* Prevent write to read-only registers */
          case SONIC_CAP2:
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
          /* Accept write to some registers only when in reset mode */
          case SONIC_DCR:
              if (s->regs[SONIC_CR] & SONIC_CR_RST) {
 -                s->regs[reg] = data & 0xbfff;
 +                s->regs[reg] = val & 0xbfff;
              } else {
                  DPRINTF("writing to DCR invalid\n");
              }
              break;
          case SONIC_DCR2:
              if (s->regs[SONIC_CR] & SONIC_CR_RST) {
 -                s->regs[reg] = data & 0xf017;
 +                s->regs[reg] = val & 0xf017;
              } else {
                  DPRINTF("writing to DCR2 invalid\n");
              }
              break;
          /* 12 lower bytes are Read Only */
          case SONIC_TCR:
 -            s->regs[reg] = data & 0xf000;
 +            s->regs[reg] = val & 0xf000;
              break;
          /* 9 lower bytes are Read Only */
          case SONIC_RCR:
 -            s->regs[reg] = data & 0xffe0;
 +            s->regs[reg] = val & 0xffe0;
              break;
          /* Ignore most significant bit */
          case SONIC_IMR:
 -            s->regs[reg] = data & 0x7fff;
 +            s->regs[reg] = val & 0x7fff;
              dp8393x_update_irq(s);
              break;
          /* Clear bits by writing 1 to them */
          case SONIC_ISR:
 -            data &= s->regs[reg];
 -            s->regs[reg] &= ~data;
 -            if (data & SONIC_ISR_RBE) {
 +            val &= s->regs[reg];
 +            s->regs[reg] &= ~val;
 +            if (val & SONIC_ISR_RBE) {
                  dp8393x_do_read_rra(s);
              }
              dp8393x_update_irq(s);
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
          case SONIC_REA:
          case SONIC_RRP:
          case SONIC_RWP:
 -            s->regs[reg] = data & 0xfffe;
 +            s->regs[reg] = val & 0xfffe;
              break;
          /* Invert written value for some registers */
          case SONIC_CRCT:
          case SONIC_FAET:
          case SONIC_MPT:
 -            s->regs[reg] = data ^ 0xffff;
 +            s->regs[reg] = val ^ 0xffff;
              break;
          /* All other registers have no special contrainst */
          default:
 -            s->regs[reg] = data;
 +            s->regs[reg] = val;
      }
--    ret = qemu_chr_fe_write_all(out, (uint8_t *)&len, sizeof(len));
+     if (reg == SONIC_WT0 || reg == SONIC_WT1) {
-+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
-     if (ret != sizeof(len)) {
+ static const MemoryRegionOps dp8393x_ops = {
-         goto err;
+     .read = dp8393x_read,
-     }
+     .write = dp8393x_write,
+-    .impl.min_access_size = 2,
--    ret = qemu_chr_fe_write_all(out, (uint8_t *)buf, size);
+-    .impl.max_access_size = 2,
-+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
++    .impl.min_access_size = 4,
-     if (ret != size) {
++    .impl.max_access_size = 4,
-         goto err;
+     .endianness = DEVICE_NATIVE_ENDIAN,
-     }
+ };
-@@ -XXX,XX +XXX,XX @@ static void compare_pri_rs_finalize(SocketReadState *pri_rs)
      if (packet_enqueue(s, PRIMARY_IN)) {
          trace_colo_compare_main("primary: unsupported packet in");
 -        compare_chr_send(&s->chr_out, pri_rs->buf, pri_rs->packet_len);
 +        compare_chr_send(s, pri_rs->buf, pri_rs->packet_len);
      } else {
          /* compare connection */
          g_queue_foreach(&s->conn_list, colo_compare_connection, s);
@@ -XXX,XX +XXX,XX @@ static void colo_flush_packets(void *opaque, void *user_data)
      while (!g_queue_is_empty(&conn->primary_list)) {
          pkt = g_queue_pop_head(&conn->primary_list);
 -        compare_chr_send(&s->chr_out, pkt->data, pkt->size);
 +        compare_chr_send(s, pkt->data, pkt->size);
          packet_destroy(pkt, NULL);
      }
      while (!g_queue_is_empty(&conn->secondary_list)) {
 --
-.7.4
+.5.0

-New patch
+[PULL 03/23] dp8393x: Clean up endianness hacks
+From: Finn Thain <fthain@telegraphics.com.au>
+According to the datasheet, section 3.4.4, "in 32-bit mode ... the SONIC
+always writes long words".
+Therefore, use the same technique for the 'in_use' field that is used
+everywhere else, and write the full long word.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 17 ++++++-----------
+file changed, 6 insertions(+), 11 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+         return -1;
+     }
+-    /* XXX: Check byte ordering */
+-
+     /* Check for EOL */
+     if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
+         /* Are we still in resource exhaustion? */
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+         /* EOL detected */
+         s->regs[SONIC_ISR] |= SONIC_ISR_RDE;
+     } else {
+-        /* Clear in_use, but it is always 16bit wide */
+-        int offset = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
+-        if (s->big_endian && width == 2) {
+-            /* we need to adjust the offset of the 16bit field */
+-            offset += sizeof(uint16_t);
+-        }
+-        s->data[0] = 0;
+-        address_space_write(&s->as, offset, MEMTXATTRS_UNSPECIFIED,
+-                            s->data, sizeof(uint16_t));
++        /* Clear in_use */
++        size = sizeof(uint16_t) * width;
++        address = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
++        dp8393x_put(s, width, 0, 0);
++        address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
++                            s->data, size);
+         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
+         s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
+--
+.5.0

-New patch
+[PULL 04/23] dp8393x: Have dp8393x_receive() return the packet size
+From: Finn Thain <fthain@telegraphics.com.au>
+This function re-uses its 'size' argument as a scratch variable.
+Instead, declare a local 'size' variable for that purpose so that the
+function result doesn't get messed up.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 9 +++++----
+file changed, 5 insertions(+), 4 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
+ }
+ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+-                               size_t size)
++                               size_t pkt_size)
+ {
+     dp8393xState *s = qemu_get_nic_opaque(nc);
+     int packet_type;
+     uint32_t available, address;
+-    int width, rx_len = size;
++    int width, rx_len = pkt_size;
+     uint32_t checksum;
++    int size;
+     width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
+     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
+         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
+-    packet_type = dp8393x_receive_filter(s, buf, size);
++    packet_type = dp8393x_receive_filter(s, buf, pkt_size);
+     if (packet_type < 0) {
+         DPRINTF("packet not for netcard\n");
+         return -1;
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+     /* Done */
+     dp8393x_update_irq(s);
+-    return size;
++    return pkt_size;
+ }
+ static void dp8393x_reset(DeviceState *dev)
+--
+.5.0

-New patch
+[PULL 05/23] dp8393x: Update LLFA and CRDA registers from rx descriptor
+From: Finn Thain <fthain@telegraphics.com.au>
+Follow the algorithm given in the National Semiconductor DP83932C
+datasheet in section 3.4.7:
+    At the next reception, the SONIC re-reads the last RXpkt.link field,
+    and updates its CRDA register to point to the next descriptor.
+The chip is designed to allow the host to provide a new list of
+descriptors in this way.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 11 +++++++----
+file changed, 7 insertions(+), 4 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+         address = dp8393x_crda(s) + sizeof(uint16_t) * 5 * width;
+         address_space_read(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                            s->data, size);
+-        if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
++        s->regs[SONIC_LLFA] = dp8393x_get(s, width, 0);
++        if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
+             /* Still EOL ; stop reception */
+             return -1;
+-        } else {
+-            s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+         }
++        /* Link has been updated by host */
++        s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+     }
+     /* Save current position */
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+                         MEMTXATTRS_UNSPECIFIED,
+                         s->data, size);
+-    /* Move to next descriptor */
++    /* Check link field */
+     size = sizeof(uint16_t) * width;
+     address_space_read(&s->as,
+                        dp8393x_crda(s) + sizeof(uint16_t) * 5 * width,
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+         dp8393x_put(s, width, 0, 0);
+         address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                             s->data, size);
++
++        /* Move to next descriptor */
+         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
+         s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
+--
+.5.0

-New patch
+[PULL 06/23] dp8393x: Clear RRRA command register bit only when appropriate
+From: Finn Thain <fthain@telegraphics.com.au>
+It doesn't make sense to clear the command register bit unless the
+command was actually issued.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 7 +++----
+file changed, 3 insertions(+), 4 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_read_rra(dp8393xState *s)
+         s->regs[SONIC_ISR] |= SONIC_ISR_RBE;
+         dp8393x_update_irq(s);
+     }
+-
+-    /* Done */
+-    s->regs[SONIC_CR] &= ~SONIC_CR_RRRA;
+ }
+ static void dp8393x_do_software_reset(dp8393xState *s)
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_command(dp8393xState *s, uint16_t command)
+         dp8393x_do_start_timer(s);
+     if (command & SONIC_CR_RST)
+         dp8393x_do_software_reset(s);
+-    if (command & SONIC_CR_RRRA)
++    if (command & SONIC_CR_RRRA) {
+         dp8393x_do_read_rra(s);
++        s->regs[SONIC_CR] &= ~SONIC_CR_RRRA;
++    }
+     if (command & SONIC_CR_LCAM)
+         dp8393x_do_load_cam(s);
+ }
+--
+.5.0

-New patch
+[PULL 07/23] dp8393x: Implement packet size limit and RBAE interrupt
+From: Finn Thain <fthain@telegraphics.com.au>
+Add a bounds check to prevent a large packet from causing a buffer
+overflow. This is defensive programming -- I haven't actually tried
+sending an oversized packet or a jumbo ethernet frame.
+The SONIC handles packets that are too big for the buffer by raising
+the RBAE interrupt and dropping them. Linux uses that interrupt to
+count dropped packets.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 9 +++++++++
+file changed, 9 insertions(+)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ do { printf("sonic ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
+ #define SONIC_TCR_CRCI   0x2000
+ #define SONIC_TCR_PINT   0x8000
++#define SONIC_ISR_RBAE   0x0010
+ #define SONIC_ISR_RBE    0x0020
+ #define SONIC_ISR_RDE    0x0040
+ #define SONIC_ISR_TC     0x0080
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
+         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
++    if (pkt_size + 4 > dp8393x_rbwc(s) * 2) {
++        DPRINTF("oversize packet, pkt_size is %d\n", pkt_size);
++        s->regs[SONIC_ISR] |= SONIC_ISR_RBAE;
++        dp8393x_update_irq(s);
++        dp8393x_do_read_rra(s);
++        return pkt_size;
++    }
++
+     packet_type = dp8393x_receive_filter(s, buf, pkt_size);
+     if (packet_type < 0) {
+         DPRINTF("packet not for netcard\n");
+--
+.5.0

-New patch
+[PULL 08/23] dp8393x: Don't clobber packet checksum
+From: Finn Thain <fthain@telegraphics.com.au>
+A received packet consumes pkt_size bytes in the buffer and the frame
+checksum that's appended to it consumes another 4 bytes. The Receive
+Buffer Address register takes the former quantity into account but
+not the latter. So the next packet written to the buffer overwrites
+the frame checksum. Fix this.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 1 +
+file changed, 1 insertion(+)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+     address += rx_len;
+     address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                         &checksum, 4);
++    address += 4;
+     rx_len += 4;
+     s->regs[SONIC_CRBA1] = address >> 16;
+     s->regs[SONIC_CRBA0] = address & 0xffff;
+--
+.5.0

-New patch
+[PULL 09/23] dp8393x: Use long-word-aligned RRA pointers in 32-bit mode
+From: Finn Thain <fthain@telegraphics.com.au>
+Section 3.4.1 of the datasheet says,
+    The alignment of the RRA is confined to either word or long word
+    boundaries, depending upon the data width mode. In 16-bit mode,
+    the RRA must be aligned to a word boundary (A0 is always zero)
+    and in 32-bit mode, the RRA is aligned to a long word boundary
+    (A0 and A1 are always zero).
+This constraint has been implemented for 16-bit mode; implement it
+for 32-bit mode too.
+Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
+Tested-by: Laurent Vivier <laurent@vivier.eu>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/dp8393x.c | 8 ++++++--
+file changed, 6 insertions(+), 2 deletions(-)
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/dp8393x.c
++++ b/hw/net/dp8393x.c
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
+                 qemu_flush_queued_packets(qemu_get_queue(s->nic));
+             }
+             break;
+-        /* Ignore least significant bit */
++        /* The guest is required to store aligned pointers here */
+         case SONIC_RSA:
+         case SONIC_REA:
+         case SONIC_RRP:
+         case SONIC_RWP:
+-            s->regs[reg] = val & 0xfffe;
++            if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
++                s->regs[reg] = val & 0xfffc;
++            } else {
++                s->regs[reg] = val & 0xfffe;
++            }
+             break;
+         /* Invert written value for some registers */
+         case SONIC_CRCT:
+--
+.5.0

-[Qemu-devel] [PULL 01/14] net: Add vnet_hdr_len arguments in NetClientState
+[PULL 10/23] dp8393x: Pad frames to word or long word boundary
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-Add vnet_hdr_len arguments in NetClientState
+The existing code has a bug where the Remaining Buffer Word Count (RBWC)
-that make other module get real vnet_hdr_len easily.
+is calculated with a truncating division, which gives the wrong result
 for odd-sized packets.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Section 1.4.1 of the datasheet says,
     Once the end of the packet has been reached, the serializer will
     fill out the last word (16-bit mode) or long word (32-bit mode)
     if the last byte did not end on a word or long word boundary
     respectively. The fill byte will be 0FFh.
 Implement buffer padding so that buffer limits are correctly enforced.
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Tested-by: Laurent Vivier <laurent@vivier.eu>
 Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- include/net/net.h | 1 +
+ hw/net/dp8393x.c | 39 ++++++++++++++++++++++++++++-----------
- net/net.c         | 1 +
+file changed, 28 insertions(+), 11 deletions(-)
 files changed, 2 insertions(+)
-diff --git a/include/net/net.h b/include/net/net.h
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/net/net.h
+--- a/hw/net/dp8393x.c
-+++ b/include/net/net.h
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ struct NetClientState {
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
-     unsigned int queue_index;
+     dp8393xState *s = qemu_get_nic_opaque(nc);
-     unsigned rxfilter_notify_enabled:1;
+     int packet_type;
-     int vring_enable;
+     uint32_t available, address;
-+    int vnet_hdr_len;
+-    int width, rx_len = pkt_size;
-     QTAILQ_HEAD(NetFilterHead, NetFilterState) filters;
++    int width, rx_len, padded_len;
- };
+     uint32_t checksum;
+     int size;
-diff --git a/net/net.c b/net/net.c
-index XXXXXXX..XXXXXXX 100644
+-    width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
---- a/net/net.c
+-
-+++ b/net/net.c
+     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
-@@ -XXX,XX +XXX,XX @@ void qemu_set_vnet_hdr_len(NetClientState *nc, int len)
+         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
-         return;
-     }
+-    if (pkt_size + 4 > dp8393x_rbwc(s) * 2) {
++    rx_len = pkt_size + sizeof(checksum);
-+    nc->vnet_hdr_len = len;
++    if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
-     nc->info->set_vnet_hdr_len(nc, len);
++        width = 2;
- }
++        padded_len = ((rx_len - 1) | 3) + 1;
 +    } else {
 +        width = 1;
 +        padded_len = ((rx_len - 1) | 1) + 1;
 +    }
 +
 +    if (padded_len > dp8393x_rbwc(s) * 2) {
          DPRINTF("oversize packet, pkt_size is %d\n", pkt_size);
          s->regs[SONIC_ISR] |= SONIC_ISR_RBAE;
          dp8393x_update_irq(s);
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
      s->regs[SONIC_TRBA0] = s->regs[SONIC_CRBA0];
      /* Calculate the ethernet checksum */
 -    checksum = cpu_to_le32(crc32(0, buf, rx_len));
 +    checksum = cpu_to_le32(crc32(0, buf, pkt_size));
      /* Put packet into RBA */
      DPRINTF("Receive packet at %08x\n", dp8393x_crba(s));
      address = dp8393x_crba(s);
      address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
 -                        buf, rx_len);
 -    address += rx_len;
 +                        buf, pkt_size);
 +    address += pkt_size;
 +
 +    /* Put frame checksum into RBA */
      address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
 -                        &checksum, 4);
 -    address += 4;
 -    rx_len += 4;
 +                        &checksum, sizeof(checksum));
 +    address += sizeof(checksum);
 +
 +    /* Pad short packets to keep pointers aligned */
 +    if (rx_len < padded_len) {
 +        size = padded_len - rx_len;
 +        address_space_rw(&s->as, address, MEMTXATTRS_UNSPECIFIED,
 +            (uint8_t *)"\xFF\xFF\xFF", size, 1);
 +        address += size;
 +    }
 +
      s->regs[SONIC_CRBA1] = address >> 16;
      s->regs[SONIC_CRBA0] = address & 0xffff;
      available = dp8393x_rbwc(s);
 -    available -= rx_len / 2;
 +    available -= padded_len >> 1;
      s->regs[SONIC_RBWC1] = available >> 16;
      s->regs[SONIC_RBWC0] = available & 0xffff;
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 10/14] net/colo-compare.c: Add vnet packet's tcp/udp/icmp compare
+[PULL 11/23] dp8393x: Clear descriptor in_use field to release packet
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-COLO-Proxy just focus on packet payload, so we skip vnet header.
+When the SONIC receives a packet into the last available descriptor, it
 retains ownership of that descriptor for as long as necessary.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Section 3.4.7 of the datasheet says,
     When the system appends more descriptors, the SONIC releases ownership
     of the descriptor after writing 0000h to the RXpkt.in_use field.
 The packet can now be processed by the host, so raise a PKTRX interrupt,
 just like the normal case.
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Tested-by: Laurent Vivier <laurent@vivier.eu>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 8 ++++++--
+ hw/net/dp8393x.c | 10 ++++++++++
-file changed, 6 insertions(+), 2 deletions(-)
+file changed, 10 insertions(+)
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/hw/net/dp8393x.c
-+++ b/net/colo-compare.c
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_common(Packet *ppkt, Packet *spkt, int offset)
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
-                                    sec_ip_src, sec_ip_dst);
+             return -1;
          }
          /* Link has been updated by host */
 +
 +        /* Clear in_use */
 +        size = sizeof(uint16_t) * width;
 +        address = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
 +        dp8393x_put(s, width, 0, 0);
 +        address_space_rw(&s->as, address, MEMTXATTRS_UNSPECIFIED,
 +                         (uint8_t *)s->data, size, 1);
 +
 +        /* Move to next descriptor */
          s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
 +        s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
      }
-+    offset = ppkt->vnet_hdr_len + offset;
+     /* Save current position */
 +
      if (ppkt->size == spkt->size) {
 -        return memcmp(ppkt->data + offset, spkt->data + offset,
 +        return memcmp(ppkt->data + offset,
 +                      spkt->data + offset,
                        spkt->size - offset);
      } else {
          trace_colo_compare_main("Net packet size are not the same");
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
       */
      if (ptcp->th_off > 5) {
          ptrdiff_t tcp_offset;
 +
          tcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
 -                     + (ptcp->th_off * 4);
 +                     + (ptcp->th_off * 4) - ppkt->vnet_hdr_len;
          res = colo_packet_compare_common(ppkt, spkt, tcp_offset);
      } else if (ptcp->th_sum == stcp->th_sum) {
          res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN);
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 03/14] net/filter-mirror.c: Introduce parameter for filter_send()
+[PULL 12/23] dp8393x: Always update RRA pointers and sequence numbers
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-This patch change the filter_send() parameter from CharBackend to MirrorState,
+These operations need to take place regardless of whether or not
-we can get more information like vnet_hdr(We use it to support packet with vnet_header).
+rx descriptors have been used up (that is, EOL flag was observed).
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+The algorithm is now the same for a packet that was withheld as for
 a packet that was not.
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Tested-by: Laurent Vivier <laurent@vivier.eu>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/filter-mirror.c | 10 +++++-----
+ hw/net/dp8393x.c | 12 +++++++-----
-file changed, 5 insertions(+), 5 deletions(-)
+file changed, 7 insertions(+), 5 deletions(-)
-diff --git a/net/filter-mirror.c b/net/filter-mirror.c
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/filter-mirror.c
+--- a/hw/net/dp8393x.c
-+++ b/net/filter-mirror.c
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ typedef struct MirrorState {
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
-     SocketReadState rs;
+         /* Move to next descriptor */
- } MirrorState;
+         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
--static int filter_send(CharBackend *chr_out,
+-        s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
-+static int filter_send(MirrorState *s,
++    }
-                        const struct iovec *iov,
-                        int iovcnt)
+-        if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
- {
+-            /* Read next RRA */
-@@ -XXX,XX +XXX,XX @@ static int filter_send(CharBackend *chr_out,
+-            dp8393x_do_read_rra(s);
 -        }
 +    s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) |
 +                         ((s->regs[SONIC_RSC] + 1) & 0x00ff);
 +
 +    if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
 +        /* Read next RRA */
 +        dp8393x_do_read_rra(s);
      }
-     len = htonl(size);
+     /* Done */
 -    ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)&len, sizeof(len));
 +    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
      if (ret != sizeof(len)) {
          goto err;
      }
      buf = g_malloc(size);
      iov_to_buf(iov, iovcnt, 0, buf, size);
 -    ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)buf, size);
 +    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
      g_free(buf);
      if (ret != size) {
          goto err;
@@ -XXX,XX +XXX,XX @@ static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
      MirrorState *s = FILTER_MIRROR(nf);
      int ret;
 -    ret = filter_send(&s->chr_out, iov, iovcnt);
 +    ret = filter_send(s, iov, iovcnt);
      if (ret) {
          error_report("filter mirror send failed(%s)", strerror(-ret));
      }
@@ -XXX,XX +XXX,XX @@ static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
      int ret;
      if (qemu_chr_fe_backend_connected(&s->chr_out)) {
 -        ret = filter_send(&s->chr_out, iov, iovcnt);
 +        ret = filter_send(s, iov, iovcnt);
          if (ret) {
              error_report("filter redirector send failed(%s)", strerror(-ret));
          }
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 13/14] virtion-net: Prefer is_power_of_2()
+[PULL 13/23] dp8393x: Don't reset Silicon Revision register
-From: Michal Privoznik <mprivozn@redhat.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-We have a function that checks if given number is power of two.
+The jazzsonic driver in Linux uses the Silicon Revision register value
-We should prefer it instead of expanding the check on our own.
+to probe the chip. The driver fails unless the SR register contains 4.
 Unfortunately, reading this register in QEMU usually returns 0 because
 the s->regs[] array gets wiped after a software reset.
-Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
+Fixes: bd8f1ebce4 ("net/dp8393x: fix hardware reset")
 Suggested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/virtio-net.c | 2 +-
+ hw/net/dp8393x.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/virtio-net.c
+--- a/hw/net/dp8393x.c
-+++ b/hw/net/virtio-net.c
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_reset(DeviceState *dev)
-      */
+     timer_del(s->watchdog);
-     if (n->net_conf.rx_queue_size < VIRTIO_NET_RX_QUEUE_MIN_SIZE ||
-         n->net_conf.rx_queue_size > VIRTQUEUE_MAX_SIZE ||
+     memset(s->regs, 0, sizeof(s->regs));
--        (n->net_conf.rx_queue_size & (n->net_conf.rx_queue_size - 1))) {
++    s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux/mips */
-+        !is_power_of_2(n->net_conf.rx_queue_size)) {
+     s->regs[SONIC_CR] = SONIC_CR_RST | SONIC_CR_STP | SONIC_CR_RXDIS;
-         error_setg(errp, "Invalid rx_queue_size (= %" PRIu16 "), "
+     s->regs[SONIC_DCR] &= ~(SONIC_DCR_EXBUS | SONIC_DCR_LBR);
-                    "must be a power of 2 between %d and %d.",
+     s->regs[SONIC_RCR] &= ~(SONIC_RCR_LB0 | SONIC_RCR_LB1 | SONIC_RCR_BRD | SONIC_RCR_RNT);
-                    n->net_conf.rx_queue_size, VIRTIO_NET_RX_QUEUE_MIN_SIZE,
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_realize(DeviceState *dev, Error **errp)
      qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
      s->watchdog = timer_new_ns(QEMU_CLOCK_VIRTUAL, dp8393x_watchdog, s);
 -    s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux */
      memory_region_init_ram(&s->prom, OBJECT(dev),
                             "dp8393x-prom", SONIC_PROM_SIZE, &local_err);
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 04/14] net/filter-mirror.c: Make filter mirror support vnet support.
+[PULL 14/23] dp8393x: Don't stop reception upon RBE interrupt assertion
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Finn Thain <fthain@telegraphics.com.au>
-We add the vnet_hdr_support option for filter-mirror, default is disabled.
+Section 3.4.7 of the datasheet explains that,
 If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
 You can use it for example:
 -object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0,vnet_hdr_support
-If it has vnet_hdr_support flag, we will change the sending packet format from
+    The RBE bit in the Interrupt Status register is set when the
-struct {int size; const uint8_t buf[];} to {int size; int vnet_hdr_len; const uint8_t buf[];}.
+    SONIC finishes using the second to last receive buffer and reads
-make other module(like colo-compare) know how to parse net packet correctly.
+    the last RRA descriptor. Actually, the SONIC is not truly out of
     resources, but gives the system an early warning of an impending
     out of resources condition.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+RBE does not mean actual receive buffer exhaustion, and reception should
 not be stopped. This is important because Linux will not check and clear
 the RBE interrupt until it receives another packet. But that won't
 happen if can_receive returns false. This bug causes the SONIC to become
 deaf (until reset).
 Fix this with a new flag to indicate actual receive buffer exhaustion.
 Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
 Tested-by: Laurent Vivier <laurent@vivier.eu>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/filter-mirror.c | 42 +++++++++++++++++++++++++++++++++++++++++-
+ hw/net/dp8393x.c | 35 ++++++++++++++++++++++-------------
- qemu-options.hx     |  5 ++---
+file changed, 22 insertions(+), 13 deletions(-)
 files changed, 43 insertions(+), 4 deletions(-)
-diff --git a/net/filter-mirror.c b/net/filter-mirror.c
+diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/filter-mirror.c
+--- a/hw/net/dp8393x.c
-+++ b/net/filter-mirror.c
++++ b/hw/net/dp8393x.c
-@@ -XXX,XX +XXX,XX @@ typedef struct MirrorState {
+@@ -XXX,XX +XXX,XX @@ typedef struct dp8393xState {
-     CharBackend chr_in;
+     /* Hardware */
-     CharBackend chr_out;
+     uint8_t it_shift;
-     SocketReadState rs;
+     bool big_endian;
-+    bool vnet_hdr;
++    bool last_rba_is_full;
- } MirrorState;
+     qemu_irq irq;
+ #ifdef DEBUG_SONIC
- static int filter_send(MirrorState *s,
+     int irq_level;
-                        const struct iovec *iov,
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_read_rra(dp8393xState *s)
-                        int iovcnt)
+         s->regs[SONIC_RRP] = s->regs[SONIC_RSA];
  {
 +    NetFilterState *nf = NETFILTER(s);
      int ret = 0;
      ssize_t size = 0;
      uint32_t len = 0;
@@ -XXX,XX +XXX,XX @@ static int filter_send(MirrorState *s,
          goto err;
      }
-+    if (s->vnet_hdr) {
+-    /* Check resource exhaustion */
-+        /*
++    /* Warn the host if CRBA now has the last available resource */
-+         * If vnet_hdr = on, we send vnet header len to make other
+     if (s->regs[SONIC_RRP] == s->regs[SONIC_RWP])
-+         * module(like colo-compare) know how to parse net
+     {
-+         * packet correctly.
+         s->regs[SONIC_ISR] |= SONIC_ISR_RBE;
-+         */
+         dp8393x_update_irq(s);
-+        ssize_t vnet_hdr_len;
+     }
 +
-+        vnet_hdr_len = nf->netdev->vnet_hdr_len;
++    /* Allow packet reception */
-+
++    s->last_rba_is_full = false;
-+        len = htonl(vnet_hdr_len);
+ }
-+        ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
-+        if (ret != sizeof(len)) {
+ static void dp8393x_do_software_reset(dp8393xState *s)
-+            goto err;
+@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
-+        }
+                 dp8393x_do_read_rra(s);
              }
              dp8393x_update_irq(s);
 -            if (dp8393x_can_receive(s->nic->ncs)) {
 -                qemu_flush_queued_packets(qemu_get_queue(s->nic));
 -            }
              break;
          /* The guest is required to store aligned pointers here */
          case SONIC_RSA:
@@ -XXX,XX +XXX,XX @@ static int dp8393x_can_receive(NetClientState *nc)
      if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
          return 0;
 -    if (s->regs[SONIC_ISR] & SONIC_ISR_RBE)
 -        return 0;
      return 1;
  }
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
      s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
          SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
 +    if (s->last_rba_is_full) {
 +        return pkt_size;
 +    }
 +
-     buf = g_malloc(size);
+     rx_len = pkt_size + sizeof(checksum);
-     iov_to_buf(iov, iovcnt, 0, buf, size);
+     if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
-     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
+         width = 2;
-@@ -XXX,XX +XXX,XX @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
-         }
+         DPRINTF("oversize packet, pkt_size is %d\n", pkt_size);
          s->regs[SONIC_ISR] |= SONIC_ISR_RBAE;
          dp8393x_update_irq(s);
 -        dp8393x_do_read_rra(s);
 -        return pkt_size;
 +        s->regs[SONIC_RCR] |= SONIC_RCR_LPKT;
 +        goto done;
      }
--    net_socket_rs_init(&s->rs, redirector_rs_finalize, false);
+     packet_type = dp8393x_receive_filter(s, buf, pkt_size);
-+    net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
+@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
+         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
      if (s->indev) {
          chr = qemu_chr_find(s->indev);
@@ -XXX,XX +XXX,XX @@ static void filter_mirror_set_outdev(Object *obj,
      }
++    dp8393x_update_irq(s);
++
+     s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) |
+                          ((s->regs[SONIC_RSC] + 1) & 0x00ff);
++done:
++
+     if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
+-        /* Read next RRA */
+-        dp8393x_do_read_rra(s);
++        if (s->regs[SONIC_RRP] == s->regs[SONIC_RWP]) {
++            /* Stop packet reception */
++            s->last_rba_is_full = true;
++        } else {
++            /* Read next resource */
++            dp8393x_do_read_rra(s);
++        }
+     }
+-    /* Done */
+-    dp8393x_update_irq(s);
+-
+     return pkt_size;
  }
-+static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
-+{
-+    MirrorState *s = FILTER_MIRROR(obj);
-+
-+    return s->vnet_hdr;
-+}
-+
-+static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
-+{
-+    MirrorState *s = FILTER_MIRROR(obj);
-+
-+    s->vnet_hdr = value;
-+}
-+
- static char *filter_redirector_get_outdev(Object *obj, Error **errp)
- {
-     MirrorState *s = FILTER_REDIRECTOR(obj);
-@@ -XXX,XX +XXX,XX @@ static void filter_redirector_set_outdev(Object *obj,
- static void filter_mirror_init(Object *obj)
- {
-+    MirrorState *s = FILTER_MIRROR(obj);
-+
-     object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
-                             filter_mirror_set_outdev, NULL);
-+
-+    s->vnet_hdr = false;
-+    object_property_add_bool(obj, "vnet_hdr_support",
-+                             filter_mirror_get_vnet_hdr,
-+                             filter_mirror_set_vnet_hdr, NULL);
- }
- static void filter_redirector_init(Object *obj)
-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 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
- @option{tx}: the filter is attached to the transmit queue of the netdev,
-              where it will receive packets sent by the netdev.
--@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
-+@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
--filter-mirror on netdev @var{netdevid},mirror net packet to chardev
--@var{chardevid}
-+filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
- @item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},
- outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 02/14] net/net.c: Add vnet_hdr support in SocketReadState
+[PULL 15/23] e1000e: Avoid hw_error if legacy mode used
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Yuri Benditovich <yuri.benditovich@daynix.com>
-We add a flag to decide whether net_fill_rstate() need read
+https://bugzilla.redhat.com/show_bug.cgi?id=1787142
-the vnet_hdr_len or not.
+The emulation issues hw_error if PSRCTL register
 is written, for example, with zero value.
 Such configuration does not present any problem when
 DTYP bits of RCTL register define legacy format of
 transfer descriptors. Current commit discards check
 for BSIZE0 and BSIZE1 when legacy mode used.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
-Suggested-by: Jason Wang <jasowang@redhat.com>
+Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- include/net/net.h   |  9 +++++++--
+ hw/net/e1000e_core.c | 13 ++++++++-----
- net/colo-compare.c  |  4 ++--
+file changed, 8 insertions(+), 5 deletions(-)
  net/filter-mirror.c |  2 +-
  net/net.c           | 36 ++++++++++++++++++++++++++++++++----
  net/socket.c        |  8 ++++----
 files changed, 46 insertions(+), 13 deletions(-)
-diff --git a/include/net/net.h b/include/net/net.h
+diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/net/net.h
+--- a/hw/net/e1000e_core.c
-+++ b/include/net/net.h
++++ b/hw/net/e1000e_core.c
-@@ -XXX,XX +XXX,XX @@ typedef struct NICState {
+@@ -XXX,XX +XXX,XX @@ e1000e_set_eitr(E1000ECore *core, int index, uint32_t val)
- } NICState;
+ static void
+ e1000e_set_psrctl(E1000ECore *core, int index, uint32_t val)
- struct SocketReadState {
+ {
--    int state; /* 0 = getting length, 1 = getting data */
+-    if ((val & E1000_PSRCTL_BSIZE0_MASK) == 0) {
-+    /* 0 = getting length, 1 = getting vnet header length, 2 = getting data */
+-        hw_error("e1000e: PSRCTL.BSIZE0 cannot be zero");
-+    int state;
+-    }
-+    /* This flag decide whether to read the vnet_hdr_len field */
++    if (core->mac[RCTL] & E1000_RCTL_DTYP_MASK) {
-+    bool vnet_hdr;
++
-     uint32_t index;
++        if ((val & E1000_PSRCTL_BSIZE0_MASK) == 0) {
-     uint32_t packet_len;
++            hw_error("e1000e: PSRCTL.BSIZE0 cannot be zero");
-+    uint32_t vnet_hdr_len;
++        }
-     uint8_t buf[NET_BUFSIZE];
-     SocketReadStateFinalize *finalize;
+-    if ((val & E1000_PSRCTL_BSIZE1_MASK) == 0) {
- };
+-        hw_error("e1000e: PSRCTL.BSIZE1 cannot be zero");
-@@ -XXX,XX +XXX,XX @@ ssize_t qemu_deliver_packet_iov(NetClientState *sender,
++        if ((val & E1000_PSRCTL_BSIZE1_MASK) == 0) {
- void print_net_client(Monitor *mon, NetClientState *nc);
++            hw_error("e1000e: PSRCTL.BSIZE1 cannot be zero");
- void hmp_info_network(Monitor *mon, const QDict *qdict);
++        }
  void net_socket_rs_init(SocketReadState *rs,
 -                        SocketReadStateFinalize *finalize);
 +                        SocketReadStateFinalize *finalize,
 +                        bool vnet_hdr);
  /* NIC info */
 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 void colo_compare_complete(UserCreatable *uc, Error **errp)
          return;
      }
--    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize);
+     core->mac[PSRCTL] = val;
 -    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize);
 +    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, false);
 +    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, false);
      g_queue_init(&s->conn_list);
 diff --git a/net/filter-mirror.c b/net/filter-mirror.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/filter-mirror.c
 +++ b/net/filter-mirror.c
@@ -XXX,XX +XXX,XX @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp)
          }
      }
 -    net_socket_rs_init(&s->rs, redirector_rs_finalize);
 +    net_socket_rs_init(&s->rs, redirector_rs_finalize, false);
      if (s->indev) {
          chr = qemu_chr_find(s->indev);
 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 @@ QemuOptsList qemu_net_opts = {
  };
  void net_socket_rs_init(SocketReadState *rs,
 -                        SocketReadStateFinalize *finalize)
 +                        SocketReadStateFinalize *finalize,
 +                        bool vnet_hdr)
  {
      rs->state = 0;
 +    rs->vnet_hdr = vnet_hdr;
      rs->index = 0;
      rs->packet_len = 0;
 +    rs->vnet_hdr_len = 0;
      memset(rs->buf, 0, sizeof(rs->buf));
      rs->finalize = finalize;
  }
@@ -XXX,XX +XXX,XX @@ int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
      unsigned int l;
      while (size > 0) {
 -        /* reassemble a packet from the network */
 -        switch (rs->state) { /* 0 = getting length, 1 = getting data */
 +        /* Reassemble a packet from the network.
 +         * 0 = getting length.
 +         * 1 = getting vnet header length.
 +         * 2 = getting data.
 +         */
 +        switch (rs->state) {
          case 0:
              l = 4 - rs->index;
              if (l > size) {
@@ -XXX,XX +XXX,XX @@ int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
                  /* got length */
                  rs->packet_len = ntohl(*(uint32_t *)rs->buf);
                  rs->index = 0;
 -                rs->state = 1;
 +                if (rs->vnet_hdr) {
 +                    rs->state = 1;
 +                } else {
 +                    rs->state = 2;
 +                    rs->vnet_hdr_len = 0;
 +                }
              }
              break;
          case 1:
 +            l = 4 - rs->index;
 +            if (l > size) {
 +                l = size;
 +            }
 +            memcpy(rs->buf + rs->index, buf, l);
 +            buf += l;
 +            size -= l;
 +            rs->index += l;
 +            if (rs->index == 4) {
 +                /* got vnet header length */
 +                rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
 +                rs->index = 0;
 +                rs->state = 2;
 +            }
 +            break;
 +        case 2:
              l = rs->packet_len - rs->index;
              if (l > size) {
                  l = size;
 diff --git a/net/socket.c b/net/socket.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/socket.c
 +++ b/net/socket.c
@@ -XXX,XX +XXX,XX @@ static void net_socket_send(void *opaque)
          closesocket(s->fd);
          s->fd = -1;
 -        net_socket_rs_init(&s->rs, net_socket_rs_finalize);
 +        net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
          s->nc.link_down = true;
          memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
      s->fd = fd;
      s->listen_fd = -1;
      s->send_fn = net_socket_send_dgram;
 -    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
 +    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
      net_socket_read_poll(s, true);
      /* mcast: save bound address as dst */
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
      s->fd = fd;
      s->listen_fd = -1;
 -    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
 +    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
      /* Disable Nagle algorithm on TCP sockets to reduce latency */
      socket_set_nodelay(fd);
@@ -XXX,XX +XXX,XX @@ static int net_socket_listen_init(NetClientState *peer,
      s->fd = -1;
      s->listen_fd = fd;
      s->nc.link_down = true;
 -    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
 +    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
      qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
      return 0;
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 08/14] net/colo-compare.c: Make colo-compare support vnet_hdr_len
+[PULL 16/23] NetRxPkt: Introduce support for additional hash types
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Yuri Benditovich <yuri.benditovich@daynix.com>
-We add the vnet_hdr_support option for colo-compare, default is disabled.
+Add support for following hash types:
-If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
+IPV6 TCP with extension headers
-You can use it for example:
+IPV4 UDP
--object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,outdev=compare_out0,vnet_hdr_support
+IPV6 UDP
 IPV6 UDP with extension headers
-COLO-compare can get vnet header length from filter,
+Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
-Add vnet_hdr_len to struct packet and output packet with
+Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 the vnet_hdr_len.
 Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-------
+ hw/net/net_rx_pkt.c | 42 ++++++++++++++++++++++++++++++++++++++++++
- qemu-options.hx    |  4 ++--
+ hw/net/net_rx_pkt.h |  6 +++++-
-files changed, 55 insertions(+), 9 deletions(-)
+ hw/net/trace-events |  4 ++++
 files changed, 51 insertions(+), 1 deletion(-)
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+diff --git a/hw/net/net_rx_pkt.c b/hw/net/net_rx_pkt.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/hw/net/net_rx_pkt.c
-+++ b/net/colo-compare.c
++++ b/hw/net/net_rx_pkt.c
-@@ -XXX,XX +XXX,XX @@ typedef struct CompareState {
+@@ -XXX,XX +XXX,XX @@ _net_rx_rss_prepare_tcp(uint8_t *rss_input,
-     CharBackend chr_out;
+                           &tcphdr->th_dport, sizeof(uint16_t));
-     SocketReadState pri_rs;
+ }
-     SocketReadState sec_rs;
-+    bool vnet_hdr;
++static inline void
++_net_rx_rss_prepare_udp(uint8_t *rss_input,
-     /* connection list: the connections belonged to this NIC could be found
++                        struct NetRxPkt *pkt,
-      * in this list.
++                        size_t *bytes_written)
-@@ -XXX,XX +XXX,XX @@ enum {
++{
++    struct udp_header *udphdr = &pkt->l4hdr_info.hdr.udp;
  static int compare_chr_send(CompareState *s,
                              const uint8_t *buf,
 -                            uint32_t size);
 +                            uint32_t size,
 +                            uint32_t vnet_hdr_len);
  static gint seq_sorter(Packet *a, Packet *b, gpointer data)
  {
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
          }
          if (result) {
 -            ret = compare_chr_send(s, pkt->data, pkt->size);
 +            ret = compare_chr_send(s,
 +                                   pkt->data,
 +                                   pkt->size,
 +                                   pkt->vnet_hdr_len);
              if (ret < 0) {
                  error_report("colo_send_primary_packet failed");
              }
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
  static int compare_chr_send(CompareState *s,
                              const uint8_t *buf,
 -                            uint32_t size)
 +                            uint32_t size,
 +                            uint32_t vnet_hdr_len)
  {
      int ret = 0;
      uint32_t len = htonl(size);
@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CompareState *s,
          goto err;
      }
 +    if (s->vnet_hdr) {
 +        /*
 +         * We send vnet header len make other module(like filter-redirector)
 +         * know how to parse net packet correctly.
 +         */
 +        len = htonl(vnet_hdr_len);
 +        ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
 +        if (ret != sizeof(len)) {
 +            goto err;
 +        }
 +    }
 +
-     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
++    _net_rx_rss_add_chunk(rss_input, bytes_written,
-     if (ret != size) {
++                          &udphdr->uh_sport, sizeof(uint16_t));
          goto err;
@@ -XXX,XX +XXX,XX @@ static void compare_set_outdev(Object *obj, const char *value, Error **errp)
      s->outdev = g_strdup(value);
  }
 +static bool compare_get_vnet_hdr(Object *obj, Error **errp)
 +{
 +    CompareState *s = COLO_COMPARE(obj);
 +
-+    return s->vnet_hdr;
++    _net_rx_rss_add_chunk(rss_input, bytes_written,
 +                          &udphdr->uh_dport, sizeof(uint16_t));
 +}
 +
-+static void compare_set_vnet_hdr(Object *obj,
+ uint32_t
-+                                 bool value,
+ net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
-+                                 Error **errp)
+                          NetRxPktRssType type,
-+{
+@@ -XXX,XX +XXX,XX @@ net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
-+    CompareState *s = COLO_COMPARE(obj);
+         trace_net_rx_pkt_rss_ip6_ex();
-+
+         _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
-+    s->vnet_hdr = value;
+         break;
-+}
++    case NetPktRssIpV6TcpEx:
-+
++        assert(pkt->isip6);
- static void compare_pri_rs_finalize(SocketReadState *pri_rs)
++        assert(pkt->istcp);
- {
++        trace_net_rx_pkt_rss_ip6_ex_tcp();
-     CompareState *s = container_of(pri_rs, CompareState, pri_rs);
++        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
++        _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
-     if (packet_enqueue(s, PRIMARY_IN)) {
++        break;
-         trace_colo_compare_main("primary: unsupported packet in");
++    case NetPktRssIpV4Udp:
--        compare_chr_send(s, pri_rs->buf, pri_rs->packet_len);
++        assert(pkt->isip4);
-+        compare_chr_send(s,
++        assert(pkt->isudp);
-+                         pri_rs->buf,
++        trace_net_rx_pkt_rss_ip4_udp();
-+                         pri_rs->packet_len,
++        _net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
-+                         pri_rs->vnet_hdr_len);
++        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
-     } else {
++        break;
-         /* compare connection */
++    case NetPktRssIpV6Udp:
-         g_queue_foreach(&s->conn_list, colo_compare_connection, s);
++        assert(pkt->isip6);
-@@ -XXX,XX +XXX,XX @@ static void colo_compare_complete(UserCreatable *uc, Error **errp)
++        assert(pkt->isudp);
-         return;
++        trace_net_rx_pkt_rss_ip6_udp();
-     }
++        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
++        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
--    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, false);
++        break;
--    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, false);
++    case NetPktRssIpV6UdpEx:
-+    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, s->vnet_hdr);
++        assert(pkt->isip6);
-+    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, s->vnet_hdr);
++        assert(pkt->isudp);
++        trace_net_rx_pkt_rss_ip6_ex_udp();
-     g_queue_init(&s->conn_list);
++        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
++        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
-@@ -XXX,XX +XXX,XX @@ static void colo_flush_packets(void *opaque, void *user_data)
++        break;
+     default:
-     while (!g_queue_is_empty(&conn->primary_list)) {
+         assert(false);
-         pkt = g_queue_pop_head(&conn->primary_list);
+         break;
--        compare_chr_send(s, pkt->data, pkt->size);
+diff --git a/hw/net/net_rx_pkt.h b/hw/net/net_rx_pkt.h
 +        compare_chr_send(s,
 +                         pkt->data,
 +                         pkt->size,
 +                         pkt->vnet_hdr_len);
          packet_destroy(pkt, NULL);
      }
      while (!g_queue_is_empty(&conn->secondary_list)) {
@@ -XXX,XX +XXX,XX @@ static void colo_compare_class_init(ObjectClass *oc, void *data)
  static void colo_compare_init(Object *obj)
  {
 +    CompareState *s = COLO_COMPARE(obj);
 +
      object_property_add_str(obj, "primary_in",
                              compare_get_pri_indev, compare_set_pri_indev,
                              NULL);
@@ -XXX,XX +XXX,XX @@ static void colo_compare_init(Object *obj)
      object_property_add_str(obj, "outdev",
                              compare_get_outdev, compare_set_outdev,
                              NULL);
 +
 +    s->vnet_hdr = false;
 +    object_property_add_bool(obj, "vnet_hdr_support", compare_get_vnet_hdr,
 +                             compare_set_vnet_hdr, NULL);
  }
  static void colo_compare_finalize(Object *obj)
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-options.hx
+--- a/hw/net/net_rx_pkt.h
-+++ b/qemu-options.hx
++++ b/hw/net/net_rx_pkt.h
-@@ -XXX,XX +XXX,XX @@ Dump the network traffic on netdev @var{dev} to the file specified by
+@@ -XXX,XX +XXX,XX @@ typedef enum {
- The file format is libpcap, so it can be analyzed with tools such as tcpdump
+     NetPktRssIpV4Tcp,
- or Wireshark.
+     NetPktRssIpV6Tcp,
+     NetPktRssIpV6,
--@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},
+-    NetPktRssIpV6Ex
--outdev=@var{chardevid}
++    NetPktRssIpV6Ex,
-+@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},outdev=@var{chardevid}[,vnet_hdr_support]
++    NetPktRssIpV6TcpEx,
++    NetPktRssIpV4Udp,
- Colo-compare gets packet from primary_in@var{chardevid} and secondary_in@var{chardevid}, than compare primary packet with
++    NetPktRssIpV6Udp,
- secondary packet. If the packets are same, we will output primary
++    NetPktRssIpV6UdpEx,
- packet to outdev@var{chardevid}, else we will notify colo-frame
+ } NetRxPktRssType;
- do checkpoint and send primary packet to outdev@var{chardevid}.
-+if it has the vnet_hdr_support flag, colo compare will send/recv packet with vnet_hdr_len.
+ /**
+diff --git a/hw/net/trace-events b/hw/net/trace-events
- we must use it with the help of filter-mirror and filter-redirector.
+index XXXXXXX..XXXXXXX 100644
 --- a/hw/net/trace-events
 +++ b/hw/net/trace-events
@@ -XXX,XX +XXX,XX @@ net_rx_pkt_l3_csum_validate_csum(size_t l3hdr_off, uint32_t csl, uint32_t cntr,
  net_rx_pkt_rss_ip4(void) "Calculating IPv4 RSS  hash"
  net_rx_pkt_rss_ip4_tcp(void) "Calculating IPv4/TCP RSS  hash"
 +net_rx_pkt_rss_ip4_udp(void) "Calculating IPv4/UDP RSS  hash"
  net_rx_pkt_rss_ip6_tcp(void) "Calculating IPv6/TCP RSS  hash"
 +net_rx_pkt_rss_ip6_udp(void) "Calculating IPv6/UDP RSS  hash"
  net_rx_pkt_rss_ip6(void) "Calculating IPv6 RSS  hash"
  net_rx_pkt_rss_ip6_ex(void) "Calculating IPv6/EX RSS  hash"
 +net_rx_pkt_rss_ip6_ex_tcp(void) "Calculating IPv6/EX/TCP RSS  hash"
 +net_rx_pkt_rss_ip6_ex_udp(void) "Calculating IPv6/EX/UDP RSS  hash"
  net_rx_pkt_rss_hash(size_t rss_length, uint32_t rss_hash) "RSS hash for %zu bytes: 0x%X"
  net_rx_pkt_rss_add_chunk(void* ptr, size_t size, size_t input_offset) "Add RSS chunk %p, %zu bytes, RSS input offset %zu bytes"
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 14/14] virtio-net: fix offload ctrl endian
+[PULL 17/23] NetRxPkt: fix hash calculation of IPV6 TCP
-Spec said offloads should be le64, so use virtio_ldq_p() to guarantee
+From: Yuri Benditovich <yuri.benditovich@daynix.com>
 valid endian.
-Fixes: 644c98587d4c ("virtio-net: dynamic network offloads configuration")
+When requested to calculate the hash for TCPV6 packet,
-Cc: qemu-stable@nongnu.org
+ignore overrides of source and destination addresses
-Cc: Dmitry Fleytman <dfleytma@redhat.com>
+in in extension headers.
 Use these overrides when new hash type NetPktRssIpV6TcpEx
 requested.
 Use this type in e1000e hash calculation for IPv6 TCP, which
 should take in account overrides of the addresses.
 Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
 Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/virtio-net.c | 2 ++
+ hw/net/e1000e_core.c | 2 +-
-file changed, 2 insertions(+)
+ hw/net/net_rx_pkt.c  | 2 +-
 files changed, 2 insertions(+), 2 deletions(-)
-diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
+diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/virtio-net.c
+--- a/hw/net/e1000e_core.c
-+++ b/hw/net/virtio-net.c
++++ b/hw/net/e1000e_core.c
-@@ -XXX,XX +XXX,XX @@ static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
+@@ -XXX,XX +XXX,XX @@ e1000e_rss_calc_hash(E1000ECore *core,
-     if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
+         type = NetPktRssIpV4Tcp;
-         uint64_t supported_offloads;
+         break;
+     case E1000_MRQ_RSS_TYPE_IPV6TCP:
-+        offloads = virtio_ldq_p(vdev, &offloads);
+-        type = NetPktRssIpV6Tcp;
-+
++        type = NetPktRssIpV6TcpEx;
-         if (!n->has_vnet_hdr) {
+         break;
-             return VIRTIO_NET_ERR;
+     case E1000_MRQ_RSS_TYPE_IPV6:
-         }
+         type = NetPktRssIpV6;
 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_rss_hash(struct NetRxPkt *pkt,
          assert(pkt->isip6);
          assert(pkt->istcp);
          trace_net_rx_pkt_rss_ip6_tcp();
 -        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
 +        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
          _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
          break;
      case NetPktRssIpV6:
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 12/14] docs/colo-proxy.txt: Update colo-proxy usage of net driver with vnet_header
+[PULL 18/23] hw: net: cadence_gem: Fix build errors in DB_PRINT()
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Bin Meng <bmeng.cn@gmail.com>
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+When CADENCE_GEM_ERR_DEBUG is turned on, there are several
 compilation errors in DB_PRINT(). Fix them.
 While we are here, update to use appropriate modifiers in
 the same DB_PRINT() call.
 Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
 Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- docs/colo-proxy.txt | 26 ++++++++++++++++++++++++++
+ hw/net/cadence_gem.c | 11 ++++++-----
-file changed, 26 insertions(+)
+file changed, 6 insertions(+), 5 deletions(-)
-diff --git a/docs/colo-proxy.txt b/docs/colo-proxy.txt
+diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
 index XXXXXXX..XXXXXXX 100644
---- a/docs/colo-proxy.txt
+--- a/hw/net/cadence_gem.c
-+++ b/docs/colo-proxy.txt
++++ b/hw/net/cadence_gem.c
-@@ -XXX,XX +XXX,XX @@ Secondary(ip:3.3.3.8):
+@@ -XXX,XX +XXX,XX @@ static ssize_t gem_receive(NetClientState *nc, const uint8_t *buf, size_t size)
- -chardev socket,id=red1,host=3.3.3.3,port=9004
+             return -1;
- -object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0
+         }
- -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1
-+-object filter-rewriter,id=f3,netdev=hn0,queue=all
+-        DB_PRINT("copy %d bytes to 0x%x\n", MIN(bytes_to_copy, rxbufsize),
-+
+-                rx_desc_get_buffer(s->rx_desc[q]));
-+If you want to use virtio-net-pci or other driver with vnet_header:
++        DB_PRINT("copy %u bytes to 0x%" PRIx64 "\n",
-+
++                 MIN(bytes_to_copy, rxbufsize),
-+Primary(ip:3.3.3.3):
++                 rx_desc_get_buffer(s, s->rx_desc[q]));
-+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown
-+-device e1000,id=e0,netdev=hn0,mac=52:a4:00:12:78:66
+         /* Copy packet data to emulated DMA buffer */
-+-chardev socket,id=mirror0,host=3.3.3.3,port=9003,server,nowait
+         address_space_write(&s->dma_as, rx_desc_get_buffer(s, s->rx_desc[q]) +
-+-chardev socket,id=compare1,host=3.3.3.3,port=9004,server,nowait
+@@ -XXX,XX +XXX,XX @@ static void gem_transmit(CadenceGEMState *s)
-+-chardev socket,id=compare0,host=3.3.3.3,port=9001,server,nowait
-+-chardev socket,id=compare0-0,host=3.3.3.3,port=9001
+             if (tx_desc_get_length(desc) > sizeof(tx_packet) -
-+-chardev socket,id=compare_out,host=3.3.3.3,port=9005,server,nowait
+                                                (p - tx_packet)) {
-+-chardev socket,id=compare_out0,host=3.3.3.3,port=9005
+-                DB_PRINT("TX descriptor @ 0x%x too large: size 0x%x space " \
-+-object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0,vnet_hdr_support
+-                         "0x%x\n", (unsigned)packet_desc_addr,
-+-object filter-redirector,netdev=hn0,id=redire0,queue=rx,indev=compare_out,vnet_hdr_support
+-                         (unsigned)tx_desc_get_length(desc),
-+-object filter-redirector,netdev=hn0,id=redire1,queue=rx,outdev=compare0,vnet_hdr_support
++                DB_PRINT("TX descriptor @ 0x%" HWADDR_PRIx \
-+-object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,outdev=compare_out0,vnet_hdr_support
++                         " too large: size 0x%x space 0x%zx\n",
-+
++                         packet_desc_addr, tx_desc_get_length(desc),
-+Secondary(ip:3.3.3.8):
+                          sizeof(tx_packet) - (p - tx_packet));
-+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,down script=/etc/qemu-ifdown
+                 break;
-+-device e1000,netdev=hn0,mac=52:a4:00:12:78:66
+             }
 +-chardev socket,id=red0,host=3.3.3.3,port=9003
 +-chardev socket,id=red1,host=3.3.3.3,port=9004
 +-object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0,vnet_hdr_support
 +-object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1,vnet_hdr_support
 +-object filter-rewriter,id=f3,netdev=hn0,queue=all,vnet_hdr_support
  Note:
    a.COLO-proxy must work with COLO-frame and Block-replication.
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 09/14] net/colo.c: Add vnet packet parse feature in colo-proxy
+[PULL 19/23] block/replication.c: Ignore requests after failover
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Lukas Straub <lukasstraub2@web.de>
-Make colo-compare and filter-rewriter can parse vnet packet.
+After failover the Secondary side of replication shouldn't change state, because
 it now functions as our primary disk.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+In replication_start, replication_do_checkpoint, replication_stop, ignore
 the request if current state is BLOCK_REPLICATION_DONE (sucessful failover) or
 BLOCK_REPLICATION_FAILOVER (failover in progres i.e. currently merging active
 and hidden images into the base image).
 Signed-off-by: Lukas Straub <lukasstraub2@web.de>
 Reviewed-by: Zhang Chen <chen.zhang@intel.com>
 Acked-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo.c | 6 +++---
+ block/replication.c | 35 ++++++++++++++++++++++++++++++++++-
-file changed, 3 insertions(+), 3 deletions(-)
+file changed, 34 insertions(+), 1 deletion(-)
-diff --git a/net/colo.c b/net/colo.c
+diff --git a/block/replication.c b/block/replication.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo.c
+--- a/block/replication.c
-+++ b/net/colo.c
++++ b/block/replication.c
-@@ -XXX,XX +XXX,XX @@ int parse_packet_early(Packet *pkt)
+@@ -XXX,XX +XXX,XX @@ static void replication_start(ReplicationState *rs, ReplicationMode mode,
- {
+     aio_context_acquire(aio_context);
-     int network_length;
+     s = bs->opaque;
-     static const uint8_t vlan[] = {0x81, 0x00};
--    uint8_t *data = pkt->data;
++    if (s->stage == BLOCK_REPLICATION_DONE ||
-+    uint8_t *data = pkt->data + pkt->vnet_hdr_len;
++        s->stage == BLOCK_REPLICATION_FAILOVER) {
-     uint16_t l3_proto;
++        /*
-     ssize_t l2hdr_len = eth_get_l2_hdr_length(data);
++         * This case happens when a secondary is promoted to primary.
++         * Ignore the request because the secondary side of replication
--    if (pkt->size < ETH_HLEN) {
++         * doesn't have to do anything anymore.
-+    if (pkt->size < ETH_HLEN + pkt->vnet_hdr_len) {
++         */
-         trace_colo_proxy_main("pkt->size < ETH_HLEN");
++        aio_context_release(aio_context);
-         return 1;
++        return;
 +    }
 +
      if (s->stage != BLOCK_REPLICATION_NONE) {
          error_setg(errp, "Block replication is running or done");
          aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ static void replication_do_checkpoint(ReplicationState *rs, Error **errp)
      aio_context_acquire(aio_context);
      s = bs->opaque;
 +    if (s->stage == BLOCK_REPLICATION_DONE ||
 +        s->stage == BLOCK_REPLICATION_FAILOVER) {
 +        /*
 +         * This case happens when a secondary was promoted to primary.
 +         * Ignore the request because the secondary side of replication
 +         * doesn't have to do anything anymore.
 +         */
 +        aio_context_release(aio_context);
 +        return;
 +    }
 +
      if (s->mode == REPLICATION_MODE_SECONDARY) {
          secondary_do_checkpoint(s, errp);
      }
-@@ -XXX,XX +XXX,XX @@ int parse_packet_early(Packet *pkt)
+@@ -XXX,XX +XXX,XX @@ static void replication_get_error(ReplicationState *rs, Error **errp)
-     }
+     aio_context_acquire(aio_context);
+     s = bs->opaque;
-     network_length = pkt->ip->ip_hl * 4;
--    if (pkt->size < l2hdr_len + network_length) {
+-    if (s->stage != BLOCK_REPLICATION_RUNNING) {
-+    if (pkt->size < l2hdr_len + network_length + pkt->vnet_hdr_len) {
++    if (s->stage == BLOCK_REPLICATION_NONE) {
-         trace_colo_proxy_main("pkt->size < network_header + network_length");
+         error_setg(errp, "Block replication is not running");
-         return 1;
+         aio_context_release(aio_context);
-     }
+         return;
@@ -XXX,XX +XXX,XX @@ static void replication_stop(ReplicationState *rs, bool failover, Error **errp)
      aio_context_acquire(aio_context);
      s = bs->opaque;
 +    if (s->stage == BLOCK_REPLICATION_DONE ||
 +        s->stage == BLOCK_REPLICATION_FAILOVER) {
 +        /*
 +         * This case happens when a secondary was promoted to primary.
 +         * Ignore the request because the secondary side of replication
 +         * doesn't have to do anything anymore.
 +         */
 +        aio_context_release(aio_context);
 +        return;
 +    }
 +
      if (s->stage != BLOCK_REPLICATION_RUNNING) {
          error_setg(errp, "Block replication is not running");
          aio_context_release(aio_context);
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 06/14] net/colo.c: Make vnet_hdr_len as packet property
+[PULL 20/23] tests/test-replication.c: Add test for for secondary node continuing replication
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Lukas Straub <lukasstraub2@web.de>
-We can use this property flush and send packet with vnet_hdr_len.
+This simulates the case that happens when we resume COLO after failover.
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Signed-off-by: Lukas Straub <lukasstraub2@web.de>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c    | 8 ++++++--
+ tests/test-replication.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++
- net/colo.c            | 3 ++-
+file changed, 52 insertions(+)
  net/colo.h            | 4 +++-
  net/filter-rewriter.c | 2 +-
 files changed, 12 insertions(+), 5 deletions(-)
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+diff --git a/tests/test-replication.c b/tests/test-replication.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/tests/test-replication.c
-+++ b/net/colo-compare.c
++++ b/tests/test-replication.c
-@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode)
+@@ -XXX,XX +XXX,XX @@ static void test_secondary_stop(void)
-     Connection *conn;
+     teardown_secondary();
      if (mode == PRIMARY_IN) {
 -        pkt = packet_new(s->pri_rs.buf, s->pri_rs.packet_len);
 +        pkt = packet_new(s->pri_rs.buf,
 +                         s->pri_rs.packet_len,
 +                         s->pri_rs.vnet_hdr_len);
      } else {
 -        pkt = packet_new(s->sec_rs.buf, s->sec_rs.packet_len);
 +        pkt = packet_new(s->sec_rs.buf,
 +                         s->sec_rs.packet_len,
 +                         s->sec_rs.vnet_hdr_len);
      }
      if (parse_packet_early(pkt)) {
 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 @@ void connection_destroy(void *opaque)
      g_slice_free(Connection, conn);
  }
--Packet *packet_new(const void *data, int size)
++static void test_secondary_continuous_replication(void)
-+Packet *packet_new(const void *data, int size, int vnet_hdr_len)
++{
 +    BlockBackend *top_blk, *local_blk;
 +    Error *local_err = NULL;
 +
 +    top_blk = start_secondary();
 +    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
 +    g_assert(!local_err);
 +
 +    /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
 +    local_blk = blk_by_name(S_LOCAL_DISK_ID);
 +    test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
 +
 +    /* replication will backup s_local_disk to s_hidden_disk */
 +    test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
 +                  IMG_SIZE / 2, 0, IMG_SIZE, false);
 +
 +    /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
 +    test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
 +
 +    /* do failover (active commit) */
 +    replication_stop_all(true, &local_err);
 +    g_assert(!local_err);
 +
 +    /* it should ignore all requests from now on */
 +
 +    /* start after failover */
 +    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
 +    g_assert(!local_err);
 +
 +    /* checkpoint */
 +    replication_do_checkpoint_all(&local_err);
 +    g_assert(!local_err);
 +
 +    /* stop */
 +    replication_stop_all(true, &local_err);
 +    g_assert(!local_err);
 +
 +    /* read from s_local_disk (0, IMG_SIZE / 2) */
 +    test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
 +                  0, IMG_SIZE / 2, false);
 +
 +
 +    /* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
 +    test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
 +                  IMG_SIZE / 2, 0, IMG_SIZE, false);
 +
 +    teardown_secondary();
 +}
 +
  static void test_secondary_do_checkpoint(void)
  {
-     Packet *pkt = g_slice_new(Packet);
+     BlockBackend *top_blk, *local_blk;
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-     pkt->data = g_memdup(data, size);
+     g_test_add_func("/replication/secondary/write", test_secondary_write);
-     pkt->size = size;
+     g_test_add_func("/replication/secondary/start", test_secondary_start);
-     pkt->creation_ms = qemu_clock_get_ms(QEMU_CLOCK_HOST);
+     g_test_add_func("/replication/secondary/stop",  test_secondary_stop);
-+    pkt->vnet_hdr_len = vnet_hdr_len;
++    g_test_add_func("/replication/secondary/continuous_replication",
++                    test_secondary_continuous_replication);
-     return pkt;
+     g_test_add_func("/replication/secondary/do_checkpoint",
- }
+                     test_secondary_do_checkpoint);
-diff --git a/net/colo.h b/net/colo.h
+     g_test_add_func("/replication/secondary/get_error_all",
 index XXXXXXX..XXXXXXX 100644
 --- a/net/colo.h
 +++ b/net/colo.h
@@ -XXX,XX +XXX,XX @@ typedef struct Packet {
      int size;
      /* Time of packet creation, in wall clock ms */
      int64_t creation_ms;
 +    /* Get vnet_hdr_len from filter */
 +    uint32_t vnet_hdr_len;
  } Packet;
  typedef struct ConnectionKey {
@@ -XXX,XX +XXX,XX @@ Connection *connection_get(GHashTable *connection_track_table,
                             ConnectionKey *key,
                             GQueue *conn_list);
  void connection_hashtable_reset(GHashTable *connection_track_table);
 -Packet *packet_new(const void *data, int size);
 +Packet *packet_new(const void *data, int size, int vnet_hdr_len);
  void packet_destroy(void *opaque, void *user_data);
  #endif /* QEMU_COLO_PROXY_H */
 diff --git a/net/filter-rewriter.c b/net/filter-rewriter.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/filter-rewriter.c
 +++ b/net/filter-rewriter.c
@@ -XXX,XX +XXX,XX @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
      char *buf = g_malloc0(size);
      iov_to_buf(iov, iovcnt, 0, buf, size);
 -    pkt = packet_new(buf, size);
 +    pkt = packet_new(buf, size, 0);
      g_free(buf);
      /*
 --
-.7.4
+.5.0

-[Qemu-devel] [PULL 11/14] net/filter-rewriter.c: Make filter-rewriter support vnet_hdr_len
+[PULL 21/23] net/filter.c: Add Options to insert filters anywhere in the filter list
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Lukas Straub <lukasstraub2@web.de>
-We add the vnet_hdr_support option for filter-rewriter, default is disabled.
+To switch the Secondary to Primary, we need to insert new filters
-If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
+before the filter-rewriter.
-You can use it for example:
--object filter-rewriter,id=rew0,netdev=hn0,queue=all,vnet_hdr_support
+Add the options insert= and position= to be able to insert filters
+anywhere in the filter list.
-We get the vnet_hdr_len from NetClientState that make us
-parse net packet correctly.
+position should be "head" or "tail" to insert at the head or
+tail of the filter list or it should be "id=<id>" to specify
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+the id of another filter.
 insert should be either "before" or "behind" to specify where to
 insert the new filter relative to the one specified with position.
 Signed-off-by: Lukas Straub <lukasstraub2@web.de>
 Reviewed-by: Zhang Chen <chen.zhang@intel.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/filter-rewriter.c | 37 ++++++++++++++++++++++++++++++++++++-
+ include/net/filter.h |  2 ++
- qemu-options.hx       |  4 ++--
+ net/filter.c         | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++-
-files changed, 38 insertions(+), 3 deletions(-)
+ qemu-options.hx      | 31 +++++++++++++++---
+files changed, 119 insertions(+), 6 deletions(-)
-diff --git a/net/filter-rewriter.c b/net/filter-rewriter.c
 diff --git a/include/net/filter.h b/include/net/filter.h
 index XXXXXXX..XXXXXXX 100644
---- a/net/filter-rewriter.c
+--- a/include/net/filter.h
-+++ b/net/filter-rewriter.c
++++ b/include/net/filter.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ struct NetFilterState {
- #include "qemu-common.h"
+     NetClientState *netdev;
- #include "qapi/error.h"
+     NetFilterDirection direction;
- #include "qapi/qmp/qerror.h"
+     bool on;
-+#include "qemu/error-report.h"
++    char *position;
- #include "qapi-visit.h"
++    bool insert_before_flag;
- #include "qom/object.h"
+     QTAILQ_ENTRY(NetFilterState) next;
- #include "qemu/main-loop.h"
+ };
-@@ -XXX,XX +XXX,XX @@ typedef struct RewriterState {
-     NetQueue *incoming_queue;
+diff --git a/net/filter.c b/net/filter.c
-     /* hashtable to save connection */
+index XXXXXXX..XXXXXXX 100644
-     GHashTable *connection_track_table;
+--- a/net/filter.c
-+    bool vnet_hdr;
++++ b/net/filter.c
- } RewriterState;
+@@ -XXX,XX +XXX,XX @@ static void netfilter_set_status(Object *obj, const char *str, Error **errp)
+     }
- static void filter_rewriter_flush(NetFilterState *nf)
+ }
-@@ -XXX,XX +XXX,XX @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
-     ConnectionKey key;
++static char *netfilter_get_position(Object *obj, Error **errp)
-     Packet *pkt;
++{
-     ssize_t size = iov_size(iov, iovcnt);
++    NetFilterState *nf = NETFILTER(obj);
-+    ssize_t vnet_hdr_len = 0;
++
-     char *buf = g_malloc0(size);
++    return g_strdup(nf->position);
++}
-     iov_to_buf(iov, iovcnt, 0, buf, size);
++
--    pkt = packet_new(buf, size, 0);
++static void netfilter_set_position(Object *obj, const char *str, Error **errp)
-+
++{
-+    if (s->vnet_hdr) {
++    NetFilterState *nf = NETFILTER(obj);
-+        vnet_hdr_len = nf->netdev->vnet_hdr_len;
++
 +    nf->position = g_strdup(str);
 +}
 +
 +static char *netfilter_get_insert(Object *obj, Error **errp)
 +{
 +    NetFilterState *nf = NETFILTER(obj);
 +
 +    return nf->insert_before_flag ? g_strdup("before") : g_strdup("behind");
 +}
 +
 +static void netfilter_set_insert(Object *obj, const char *str, Error **errp)
 +{
 +    NetFilterState *nf = NETFILTER(obj);
 +
 +    if (strcmp(str, "before") && strcmp(str, "behind")) {
 +        error_setg(errp, "Invalid value for netfilter insert, "
 +                         "should be 'before' or 'behind'");
 +        return;
 +    }
 +
-+    pkt = packet_new(buf, size, vnet_hdr_len);
++    nf->insert_before_flag = !strcmp(str, "before");
-     g_free(buf);
++}
++
-     /*
+ static void netfilter_init(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void colo_rewriter_setup(NetFilterState *nf, Error **errp)
      s->incoming_queue = qemu_new_net_queue(qemu_netfilter_pass_to_next, nf);
  }
 +static bool filter_rewriter_get_vnet_hdr(Object *obj, Error **errp)
 +{
 +    RewriterState *s = FILTER_COLO_REWRITER(obj);
 +
 +    return s->vnet_hdr;
 +}
 +
 +static void filter_rewriter_set_vnet_hdr(Object *obj,
 +                                         bool value,
 +                                         Error **errp)
 +{
 +    RewriterState *s = FILTER_COLO_REWRITER(obj);
 +
 +    s->vnet_hdr = value;
 +}
 +
 +static void filter_rewriter_init(Object *obj)
 +{
 +    RewriterState *s = FILTER_COLO_REWRITER(obj);
 +
 +    s->vnet_hdr = false;
 +    object_property_add_bool(obj, "vnet_hdr_support",
 +                             filter_rewriter_get_vnet_hdr,
 +                             filter_rewriter_set_vnet_hdr, NULL);
 +}
 +
  static void colo_rewriter_class_init(ObjectClass *oc, void *data)
  {
-     NetFilterClass *nfc = NETFILTER_CLASS(oc);
+     NetFilterState *nf = NETFILTER(obj);
-@@ -XXX,XX +XXX,XX @@ static const TypeInfo colo_rewriter_info = {
-     .name = TYPE_FILTER_REWRITER,
+     nf->on = true;
-     .parent = TYPE_NETFILTER,
++    nf->insert_before_flag = false;
-     .class_init = colo_rewriter_class_init,
++    nf->position = g_strdup("tail");
-+    .instance_init = filter_rewriter_init,
-     .instance_size = sizeof(RewriterState),
+     object_property_add_str(obj, "netdev",
- };
+                             netfilter_get_netdev_id, netfilter_set_netdev_id,
+@@ -XXX,XX +XXX,XX @@ static void netfilter_init(Object *obj)
      object_property_add_str(obj, "status",
                              netfilter_get_status, netfilter_set_status,
                              NULL);
 +    object_property_add_str(obj, "position",
 +                            netfilter_get_position, netfilter_set_position,
 +                            NULL);
 +    object_property_add_str(obj, "insert",
 +                            netfilter_get_insert, netfilter_set_insert,
 +                            NULL);
  }
  static void netfilter_complete(UserCreatable *uc, Error **errp)
  {
      NetFilterState *nf = NETFILTER(uc);
 +    NetFilterState *position = NULL;
      NetClientState *ncs[MAX_QUEUE_NUM];
      NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
      int queues;
@@ -XXX,XX +XXX,XX @@ static void netfilter_complete(UserCreatable *uc, Error **errp)
          return;
      }
 +    if (strcmp(nf->position, "head") && strcmp(nf->position, "tail")) {
 +        Object *container;
 +        Object *obj;
 +        char *position_id;
 +
 +        if (!g_str_has_prefix(nf->position, "id=")) {
 +            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "position",
 +                       "'head', 'tail' or 'id=<id>'");
 +            return;
 +        }
 +
 +        /* get the id from the string */
 +        position_id = g_strndup(nf->position + 3, strlen(nf->position) - 3);
 +
 +        /* Search for the position to insert before/behind */
 +        container = object_get_objects_root();
 +        obj = object_resolve_path_component(container, position_id);
 +        if (!obj) {
 +            error_setg(errp, "filter '%s' not found", position_id);
 +            g_free(position_id);
 +            return;
 +        }
 +
 +        position = NETFILTER(obj);
 +
 +        if (position->netdev != ncs[0]) {
 +            error_setg(errp, "filter '%s' belongs to a different netdev",
 +                        position_id);
 +            g_free(position_id);
 +            return;
 +        }
 +
 +        g_free(position_id);
 +    }
 +
      nf->netdev = ncs[0];
      if (nfc->setup) {
@@ -XXX,XX +XXX,XX @@ static void netfilter_complete(UserCreatable *uc, Error **errp)
              return;
          }
      }
 -    QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
 +
 +    if (position) {
 +        if (nf->insert_before_flag) {
 +            QTAILQ_INSERT_BEFORE(position, nf, next);
 +        } else {
 +            QTAILQ_INSERT_AFTER(&nf->netdev->filters, position, nf, next);
 +        }
 +    } else if (!strcmp(nf->position, "head")) {
 +        QTAILQ_INSERT_HEAD(&nf->netdev->filters, nf, next);
 +    } else if (!strcmp(nf->position, "tail")) {
 +        QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
 +    }
  }
  static void netfilter_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void netfilter_finalize(Object *obj)
          QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
      }
      g_free(nf->netdev_id);
 +    g_free(nf->position);
  }
  static void default_handle_event(NetFilterState *nf, int event, Error **errp)
 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 @@ applications, they can do this through this parameter. Its format is
+ a gnutls priority string as described at
+ @url{https://gnutls.org/manual/html_node/Priority-Strings.html}.
+-@item -object filter-buffer,id=@var{id},netdev=@var{netdevid},interval=@var{t}[,queue=@var{all|rx|tx}][,status=@var{on|off}]
++@item -object filter-buffer,id=@var{id},netdev=@var{netdevid},interval=@var{t}[,queue=@var{all|rx|tx}][,status=@var{on|off}][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
+ Interval @var{t} can't be 0, this filter batches the packet delivery: all
+ packets arriving in a given interval on netdev @var{netdevid} are delayed
+@@ -XXX,XX +XXX,XX @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
+ @option{tx}: the filter is attached to the transmit queue of the netdev,
+              where it will receive packets sent by the netdev.
+-@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
++position @var{head|tail|id=<id>} is an option to specify where the
++filter should be inserted in the filter list. It can be applied to any
++netfilter.
++
++@option{head}: the filter is inserted at the head of the filter
++               list, before any existing filters.
++
++@option{tail}: the filter is inserted at the tail of the filter
++               list, behind any existing filters (default).
++
++@option{id=<id>}: the filter is inserted before or behind the filter
++                  specified by <id>, see the insert option below.
++
++insert @var{behind|before} is an option to specify where to insert the
++new filter relative to the one specified with position=id=<id>. It can
++be applied to any netfilter.
++
++@option{before}: insert before the specified filter.
++
++@option{behind}: insert behind the specified filter (default).
++
++@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
+ filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
+-@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
++@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
+ filter-redirector on netdev @var{netdevid},redirect filter's net packet to chardev
+ @var{chardevid},and redirect indev's packet to filter.if it has the vnet_hdr_support flag,
 @@ -XXX,XX +XXX,XX @@ Create a filter-redirector we need to differ outdev id from indev id, id can not
  be the same. we can just use indev or outdev, but at least one of indev or outdev
  need to be specified.
--@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid}[,queue=@var{all|rx|tx}]
+-@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support]
-+@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support]
++@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
  Filter-rewriter is a part of COLO project.It will rewrite tcp packet to
  secondary from primary to keep secondary tcp connection,and rewrite
- tcp packet to primary from secondary make tcp packet can be handled by
+@@ -XXX,XX +XXX,XX @@ colo secondary:
--client.
+ -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1
-+client.if it has the vnet_hdr_support flag, we can parse packet with vnet header.
+ -object filter-rewriter,id=rew0,netdev=hn0,queue=all
- usage:
+-@item -object filter-dump,id=@var{id},netdev=@var{dev}[,file=@var{filename}][,maxlen=@var{len}]
- colo secondary:
++@item -object filter-dump,id=@var{id},netdev=@var{dev}[,file=@var{filename}][,maxlen=@var{len}][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
  Dump the network traffic on netdev @var{dev} to the file specified by
  @var{filename}. At most @var{len} bytes (64k by default) per packet are stored.
 --
-.7.4
+.5.0

-New patch
+[PULL 22/23] colo: Update Documentation for continuous replication
+From: Lukas Straub <lukasstraub2@web.de>
 Document the qemu command-line and qmp commands for continuous replication
 Signed-off-by: Lukas Straub <lukasstraub2@web.de>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
  docs/COLO-FT.txt           | 224 +++++++++++++++++++++++++++++++++------------
  docs/block-replication.txt |  28 ++++--
 files changed, 184 insertions(+), 68 deletions(-)
 diff --git a/docs/COLO-FT.txt b/docs/COLO-FT.txt
 index XXXXXXX..XXXXXXX 100644
 --- a/docs/COLO-FT.txt
 +++ b/docs/COLO-FT.txt
@@ -XXX,XX +XXX,XX @@ The diagram just shows the main qmp command, you can get the detail
  in test procedure.
  == Test procedure ==
 -1. Startup qemu
 -Primary:
 -# qemu-system-x86_64 -accel kvm -m 2048 -smp 2 -qmp stdio -name primary \
 -  -device piix3-usb-uhci -vnc :7 \
 -  -device usb-tablet -netdev tap,id=hn0,vhost=off \
 -  -device virtio-net-pci,id=net-pci0,netdev=hn0 \
 -  -drive if=virtio,id=primary-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
 -         children.0.file.filename=1.raw,\
 -         children.0.driver=raw -S
 -Secondary:
 -# qemu-system-x86_64 -accel kvm -m 2048 -smp 2 -qmp stdio -name secondary \
 -  -device piix3-usb-uhci -vnc :7 \
 -  -device usb-tablet -netdev tap,id=hn0,vhost=off \
 -  -device virtio-net-pci,id=net-pci0,netdev=hn0 \
 -  -drive if=none,id=secondary-disk0,file.filename=1.raw,driver=raw,node-name=node0 \
 -  -drive if=virtio,id=active-disk0,driver=replication,mode=secondary,\
 -         file.driver=qcow2,top-id=active-disk0,\
 -         file.file.filename=/mnt/ramfs/active_disk.img,\
 -         file.backing.driver=qcow2,\
 -         file.backing.file.filename=/mnt/ramfs/hidden_disk.img,\
 -         file.backing.backing=secondary-disk0 \
 -  -incoming tcp:0:8888
 -
 -2. On Secondary VM's QEMU monitor, issue command
 +Note: Here we are running both instances on the same host for testing,
 +change the IP Addresses if you want to run it on two hosts. Initally
 +127.0.0.1 is the Primary Host and 127.0.0.2 is the Secondary Host.
 +
 +== Startup qemu ==
 +1. Primary:
 +Note: Initally, $imagefolder/primary.qcow2 needs to be copied to all hosts.
 +You don't need to change any IP's here, because 0.0.0.0 listens on any
 +interface. The chardev's with 127.0.0.1 IP's loopback to the local qemu
 +instance.
 +
 +# imagefolder="/mnt/vms/colo-test-primary"
 +
 +# qemu-system-x86_64 -enable-kvm -cpu qemu64,+kvmclock -m 512 -smp 1 -qmp stdio \
 +   -device piix3-usb-uhci -device usb-tablet -name primary \
 +   -netdev tap,id=hn0,vhost=off,helper=/usr/lib/qemu/qemu-bridge-helper \
 +   -device rtl8139,id=e0,netdev=hn0 \
 +   -chardev socket,id=mirror0,host=0.0.0.0,port=9003,server,nowait \
 +   -chardev socket,id=compare1,host=0.0.0.0,port=9004,server,wait \
 +   -chardev socket,id=compare0,host=127.0.0.1,port=9001,server,nowait \
 +   -chardev socket,id=compare0-0,host=127.0.0.1,port=9001 \
 +   -chardev socket,id=compare_out,host=127.0.0.1,port=9005,server,nowait \
 +   -chardev socket,id=compare_out0,host=127.0.0.1,port=9005 \
 +   -object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0 \
 +   -object filter-redirector,netdev=hn0,id=redire0,queue=rx,indev=compare_out \
 +   -object filter-redirector,netdev=hn0,id=redire1,queue=rx,outdev=compare0 \
 +   -object iothread,id=iothread1 \
 +   -object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,\
 +outdev=compare_out0,iothread=iothread1 \
 +   -drive if=ide,id=colo-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
 +children.0.file.filename=$imagefolder/primary.qcow2,children.0.driver=qcow2 -S
 +
 +2. Secondary:
 +Note: Active and hidden images need to be created only once and the
 +size should be the same as primary.qcow2. Again, you don't need to change
 +any IP's here, except for the $primary_ip variable.
 +
 +# imagefolder="/mnt/vms/colo-test-secondary"
 +# primary_ip=127.0.0.1
 +
 +# qemu-img create -f qcow2 $imagefolder/secondary-active.qcow2 10G
 +
 +# qemu-img create -f qcow2 $imagefolder/secondary-hidden.qcow2 10G
 +
 +# qemu-system-x86_64 -enable-kvm -cpu qemu64,+kvmclock -m 512 -smp 1 -qmp stdio \
 +   -device piix3-usb-uhci -device usb-tablet -name secondary \
 +   -netdev tap,id=hn0,vhost=off,helper=/usr/lib/qemu/qemu-bridge-helper \
 +   -device rtl8139,id=e0,netdev=hn0 \
 +   -chardev socket,id=red0,host=$primary_ip,port=9003,reconnect=1 \
 +   -chardev socket,id=red1,host=$primary_ip,port=9004,reconnect=1 \
 +   -object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0 \
 +   -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1 \
 +   -object filter-rewriter,id=rew0,netdev=hn0,queue=all \
 +   -drive if=none,id=parent0,file.filename=$imagefolder/primary.qcow2,driver=qcow2 \
 +   -drive if=none,id=childs0,driver=replication,mode=secondary,file.driver=qcow2,\
 +top-id=colo-disk0,file.file.filename=$imagefolder/secondary-active.qcow2,\
 +file.backing.driver=qcow2,file.backing.file.filename=$imagefolder/secondary-hidden.qcow2,\
 +file.backing.backing=parent0 \
 +   -drive if=ide,id=colo-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
 +children.0=childs0 \
 +   -incoming tcp:0.0.0.0:9998
 +
 +
 +3. On Secondary VM's QEMU monitor, issue command
  {'execute':'qmp_capabilities'}
 -{ 'execute': 'nbd-server-start',
 -  'arguments': {'addr': {'type': 'inet', 'data': {'host': 'xx.xx.xx.xx', 'port': '8889'} } }
 -}
 -{'execute': 'nbd-server-add', 'arguments': {'device': 'secondary-disk0', 'writable': true } }
 +{'execute': 'nbd-server-start', 'arguments': {'addr': {'type': 'inet', 'data': {'host': '0.0.0.0', 'port': '9999'} } } }
 +{'execute': 'nbd-server-add', 'arguments': {'device': 'parent0', 'writable': true } }
  Note:
    a. The qmp command nbd-server-start and nbd-server-add must be run
       before running the qmp command migrate on primary QEMU
    b. Active disk, hidden disk and nbd target's length should be the
       same.
 -  c. It is better to put active disk and hidden disk in ramdisk.
 +  c. It is better to put active disk and hidden disk in ramdisk. They
 +     will be merged into the parent disk on failover.
 -3. On Primary VM's QEMU monitor, issue command:
 +4. On Primary VM's QEMU monitor, issue command:
  {'execute':'qmp_capabilities'}
 -{ 'execute': 'human-monitor-command',
 -  'arguments': {'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=xx.xx.xx.xx,file.port=8889,file.export=secondary-disk0,node-name=nbd_client0'}}
 -{ 'execute':'x-blockdev-change', 'arguments':{'parent': 'primary-disk0', 'node': 'nbd_client0' } }
 -{ 'execute': 'migrate-set-capabilities',
 -      'arguments': {'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
 -{ 'execute': 'migrate', 'arguments': {'uri': 'tcp:xx.xx.xx.xx:8888' } }
 +{'execute': 'human-monitor-command', 'arguments': {'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.2,file.port=9999,file.export=parent0,node-name=replication0'}}
 +{'execute': 'x-blockdev-change', 'arguments':{'parent': 'colo-disk0', 'node': 'replication0' } }
 +{'execute': 'migrate-set-capabilities', 'arguments': {'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
 +{'execute': 'migrate', 'arguments': {'uri': 'tcp:127.0.0.2:9998' } }
    Note:
    a. There should be only one NBD Client for each primary disk.
 -  b. xx.xx.xx.xx is the secondary physical machine's hostname or IP
 -  c. The qmp command line must be run after running qmp command line in
 +  b. The qmp command line must be run after running qmp command line in
       secondary qemu.
 -4. After the above steps, you will see, whenever you make changes to PVM, SVM will be synced.
 +5. After the above steps, you will see, whenever you make changes to PVM, SVM will be synced.
  You can issue command '{ "execute": "migrate-set-parameters" , "arguments":{ "x-checkpoint-delay": 2000 } }'
 -to change the checkpoint period time
 +to change the idle checkpoint period time
 +
 +6. Failover test
 +You can kill one of the VMs and Failover on the surviving VM:
 +
 +If you killed the Secondary, then follow "Primary Failover". After that,
 +if you want to resume the replication, follow "Primary resume replication"
 +
 +If you killed the Primary, then follow "Secondary Failover". After that,
 +if you want to resume the replication, follow "Secondary resume replication"
 +
 +== Primary Failover ==
 +The Secondary died, resume on the Primary
 +
 +{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'child': 'children.1'} }
 +{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_del replication0' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'comp0' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'iothread1' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'm0' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'redire0' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'redire1' } }
 +{'execute': 'x-colo-lost-heartbeat' }
 +
 +== Secondary Failover ==
 +The Primary died, resume on the Secondary and prepare to become the new Primary
 +
 +{'execute': 'nbd-server-stop'}
 +{'execute': 'x-colo-lost-heartbeat'}
 +
 +{'execute': 'object-del', 'arguments':{ 'id': 'f2' } }
 +{'execute': 'object-del', 'arguments':{ 'id': 'f1' } }
 +{'execute': 'chardev-remove', 'arguments':{ 'id': 'red1' } }
 +{'execute': 'chardev-remove', 'arguments':{ 'id': 'red0' } }
 +
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'mirror0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '0.0.0.0', 'port': '9003' } }, 'server': true } } } }
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'compare1', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '0.0.0.0', 'port': '9004' } }, 'server': true } } } }
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'compare0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9001' } }, 'server': true } } } }
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'compare0-0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9001' } }, 'server': false } } } }
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'compare_out', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9005' } }, 'server': true } } } }
 +{'execute': 'chardev-add', 'arguments':{ 'id': 'compare_out0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9005' } }, 'server': false } } } }
 +
 +== Primary resume replication ==
 +Resume replication after new Secondary is up.
 +
 +Start the new Secondary (Steps 2 and 3 above), then on the Primary:
 +{'execute': 'drive-mirror', 'arguments':{ 'device': 'colo-disk0', 'job-id': 'resync', 'target': 'nbd://127.0.0.2:9999/parent0', 'mode': 'existing', 'format': 'raw', 'sync': 'full'} }
 +
 +Wait until disk is synced, then:
 +{'execute': 'stop'}
 +{'execute': 'block-job-cancel', 'arguments':{ 'device': 'resync'} }
 +
 +{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.2,file.port=9999,file.export=parent0,node-name=replication0'}}
 +{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'node': 'replication0' } }
 +
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-mirror', 'id': 'm0', 'props': { 'netdev': 'hn0', 'queue': 'tx', 'outdev': 'mirror0' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire0', 'props': { 'netdev': 'hn0', 'queue': 'rx', 'indev': 'compare_out' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire1', 'props': { 'netdev': 'hn0', 'queue': 'rx', 'outdev': 'compare0' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'iothread', 'id': 'iothread1' } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'colo-compare', 'id': 'comp0', 'props': { 'primary_in': 'compare0-0', 'secondary_in': 'compare1', 'outdev': 'compare_out0', 'iothread': 'iothread1' } } }
 +
 +{'execute': 'migrate-set-capabilities', 'arguments':{ 'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
 +{'execute': 'migrate', 'arguments':{ 'uri': 'tcp:127.0.0.2:9998' } }
 +
 +Note:
 +If this Primary previously was a Secondary, then we need to insert the
 +filters before the filter-rewriter by using the
 +"'insert': 'before', 'position': 'id=rew0'" Options. See below.
 +
 +== Secondary resume replication ==
 +Become Primary and resume replication after new Secondary is up. Note
 +that now 127.0.0.1 is the Secondary and 127.0.0.2 is the Primary.
 +
 +Start the new Secondary (Steps 2 and 3 above, but with primary_ip=127.0.0.2),
 +then on the old Secondary:
 +{'execute': 'drive-mirror', 'arguments':{ 'device': 'colo-disk0', 'job-id': 'resync', 'target': 'nbd://127.0.0.1:9999/parent0', 'mode': 'existing', 'format': 'raw', 'sync': 'full'} }
 +
 +Wait until disk is synced, then:
 +{'execute': 'stop'}
 +{'execute': 'block-job-cancel', 'arguments':{ 'device': 'resync' } }
 -5. Failover test
 -You can kill Primary VM and run 'x_colo_lost_heartbeat' in Secondary VM's
 -monitor at the same time, then SVM will failover and client will not detect this
 -change.
 +{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.1,file.port=9999,file.export=parent0,node-name=replication0'}}
 +{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'node': 'replication0' } }
 -Before issuing '{ "execute": "x-colo-lost-heartbeat" }' command, we have to
 -issue block related command to stop block replication.
 -Primary:
 -  Remove the nbd child from the quorum:
 -  { 'execute': 'x-blockdev-change', 'arguments': {'parent': 'colo-disk0', 'child': 'children.1'}}
 -  { 'execute': 'human-monitor-command','arguments': {'command-line': 'drive_del blk-buddy0'}}
 -  Note: there is no qmp command to remove the blockdev now
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-mirror', 'id': 'm0', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'tx', 'outdev': 'mirror0' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire0', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'rx', 'indev': 'compare_out' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire1', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'rx', 'outdev': 'compare0' } } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'iothread', 'id': 'iothread1' } }
 +{'execute': 'object-add', 'arguments':{ 'qom-type': 'colo-compare', 'id': 'comp0', 'props': { 'primary_in': 'compare0-0', 'secondary_in': 'compare1', 'outdev': 'compare_out0', 'iothread': 'iothread1' } } }
 -Secondary:
 -  The primary host is down, so we should do the following thing:
 -  { 'execute': 'nbd-server-stop' }
 +{'execute': 'migrate-set-capabilities', 'arguments':{ 'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
 +{'execute': 'migrate', 'arguments':{ 'uri': 'tcp:127.0.0.1:9998' } }
  == TODO ==
 -1. Support continuous VM replication.
 -2. Support shared storage.
 -3. Develop the heartbeat part.
 -4. Reduce checkpoint VM’s downtime while doing checkpoint.
 +1. Support shared storage.
 +2. Develop the heartbeat part.
 +3. Reduce checkpoint VM’s downtime while doing checkpoint.
 diff --git a/docs/block-replication.txt b/docs/block-replication.txt
 index XXXXXXX..XXXXXXX 100644
 --- a/docs/block-replication.txt
 +++ b/docs/block-replication.txt
@@ -XXX,XX +XXX,XX @@ blocks that are already in QEMU.
               ^            ||                            .----------
               |            ||                            | Secondary
 Quorum          ||                            '----------
 -         /      \         ||
 -        /        \        ||
 -   Primary    2 filter
 -     disk         ^                                                             virtio-blk
 -                  |                                                                  ^
 -                3 NBD  ------->  3 NBD                                               |
 +         /      \         ||                                                           virtio-blk
 +        /        \        ||                                                               ^
 +   Primary    2 filter                                                                     |
 +     disk         ^                                                                   7 Quorum
 +                  |                                                                    /
 +                3 NBD  ------->  3 NBD                                                /
                  client    ||     server                                          2 filter
                            ||        ^                                                ^
  --------.                 ||        |                                                |
@@ -XXX,XX +XXX,XX @@ any state that would otherwise be lost by the speculative write-through
  of the NBD server into the secondary disk. So before block replication,
  the primary disk and secondary disk should contain the same data.
 +7) The secondary also has a quorum node, so after secondary failover it
 +can become the new primary and continue replication.
 +
 +
  == Failure Handling ==
  There are 7 internal errors when block replication is running:
 . I/O error on primary disk
@@ -XXX,XX +XXX,XX @@ Primary:
       leading whitespace.
 . The qmp command line must be run after running qmp command line in
       secondary qemu.
 -  6. After failover we need remove children.1 (replication driver).
 +  6. After primary failover we need remove children.1 (replication driver).
  Secondary:
    -drive if=none,driver=raw,file.filename=1.raw,id=colo1 \
 -  -drive if=xxx,id=topxxx,driver=replication,mode=secondary,top-id=topxxx\
 +  -drive if=none,id=childs1,driver=replication,mode=secondary,top-id=childs1
           file.file.filename=active_disk.qcow2,\
           file.driver=qcow2,\
           file.backing.file.filename=hidden_disk.qcow2,\
           file.backing.driver=qcow2,\
           file.backing.backing=colo1
 +  -drive if=xxx,driver=quorum,read-pattern=fifo,id=top-disk1,\
 +         vote-threshold=1,children.0=childs1
    Then run qmp command in secondary qemu:
      { 'execute': 'nbd-server-start',
@@ -XXX,XX +XXX,XX @@ Secondary:
    The primary host is down, so we should do the following thing:
    { 'execute': 'nbd-server-stop' }
 +Promote Secondary to Primary:
 +  see COLO-FT.txt
 +
  TODO:
 -1. Continuous block replication
 -2. Shared disk
 +1. Shared disk
 --
 .5.0

-[Qemu-devel] [PULL 05/14] net/filter-mirror.c: Add new option to enable vnet support for filter-redirector
+[PULL 23/23] l2tpv3: fix RFC number typo in qemu-options.hx
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Stefan Hajnoczi <stefanha@redhat.com>
-We add the vnet_hdr_support option for filter-redirector, default is disabled.
+The L2TPv3 RFC number is 3931:
-If you use virtio-net-pci net driver or other driver needs vnet_hdr, please enable it.
+https://tools.ietf.org/html/rfc3931
 Because colo-compare or other modules needs the vnet_hdr_len to parse
 packet, we add this new option send the len to others.
 You can use it for example:
 -object filter-redirector,id=r0,netdev=hn0,queue=tx,outdev=red0,vnet_hdr_support
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Reported-by: Henrik Johansson <henrikjohansson@rocketmail.com>
 Reviewed-by: Stefan Weil <sw@weilnetz.de>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/filter-mirror.c | 23 +++++++++++++++++++++++
+ qemu-options.hx | 4 ++--
- qemu-options.hx     |  6 +++---
+file changed, 2 insertions(+), 2 deletions(-)
 files changed, 26 insertions(+), 3 deletions(-)
-diff --git a/net/filter-mirror.c b/net/filter-mirror.c
-index XXXXXXX..XXXXXXX 100644
---- a/net/filter-mirror.c
-+++ b/net/filter-mirror.c
-@@ -XXX,XX +XXX,XX @@ static void filter_redirector_set_outdev(Object *obj,
-     s->outdev = g_strdup(value);
- }
-+static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
-+{
-+    MirrorState *s = FILTER_REDIRECTOR(obj);
-+
-+    return s->vnet_hdr;
-+}
-+
-+static void filter_redirector_set_vnet_hdr(Object *obj,
-+                                           bool value,
-+                                           Error **errp)
-+{
-+    MirrorState *s = FILTER_REDIRECTOR(obj);
-+
-+    s->vnet_hdr = value;
-+}
-+
- static void filter_mirror_init(Object *obj)
- {
-     MirrorState *s = FILTER_MIRROR(obj);
-@@ -XXX,XX +XXX,XX @@ static void filter_mirror_init(Object *obj)
- static void filter_redirector_init(Object *obj)
- {
-+    MirrorState *s = FILTER_REDIRECTOR(obj);
-+
-     object_property_add_str(obj, "indev", filter_redirector_get_indev,
-                             filter_redirector_set_indev, NULL);
-     object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
-                             filter_redirector_set_outdev, NULL);
-+
-+    s->vnet_hdr = false;
-+    object_property_add_bool(obj, "vnet_hdr_support",
-+                             filter_redirector_get_vnet_hdr,
-+                             filter_redirector_set_vnet_hdr, NULL);
- }
- static void filter_mirror_fini(Object *obj)
 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 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
+     "                Linux kernel 3.3+ as well as most routers can talk\n"
- filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
+     "                L2TPv3. This transport allows connecting a VM to a VM,\n"
+     "                VM to a router and even VM to Host. It is a nearly-universal\n"
--@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},
+-    "                standard (RFC3391). Note - this implementation uses static\n"
--outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
++    "                standard (RFC3931). Note - this implementation uses static\n"
-+@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
+     "                pre-configured tunnels (same as the Linux kernel).\n"
+     "                use 'src=' to specify source address\n"
- filter-redirector on netdev @var{netdevid},redirect filter's net packet to chardev
+     "                use 'dst=' to specify destination address\n"
--@var{chardevid},and redirect indev's packet to filter.
+@@ -XXX,XX +XXX,XX @@ Example (send packets from host's 1.2.3.4):
-+@var{chardevid},and redirect indev's packet to filter.if it has the vnet_hdr_support flag,
+ @end example
-+filter-redirector will redirect packet with vnet_hdr_len.
- Create a filter-redirector we need to differ outdev id from indev id, id can not
+ @item -netdev l2tpv3,id=@var{id},src=@var{srcaddr},dst=@var{dstaddr}[,srcport=@var{srcport}][,dstport=@var{dstport}],txsession=@var{txsession}[,rxsession=@var{rxsession}][,ipv6][,udp][,cookie64][,counter][,pincounter][,txcookie=@var{txcookie}][,rxcookie=@var{rxcookie}][,offset=@var{offset}]
- be the same. we can just use indev or outdev, but at least one of indev or outdev
+-Configure a L2TPv3 pseudowire host network backend. L2TPv3 (RFC3391) is a
- need to be specified.
++Configure a L2TPv3 pseudowire host network backend. L2TPv3 (RFC3931) is a
  popular protocol to transport Ethernet (and other Layer 2) data frames between
  two systems. It is present in routers, firewalls and the Linux kernel
  (from version 3.3 onwards).
 --
-.7.4
+.5.0

The following changes since commit 6632f6ff96f0537fc34cdc00c760656fc62e23c5:

Merge remote-tracking branch 'remotes/famz/tags/block-and-testing-pull-request' into staging (2017-07-17 11:46:36 +0100)

are available in the git repository at:

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

for you to fetch changes up to 189ae6bb5ce1f5a322f8691d00fe942ba43dd601:

virtio-net: fix offload ctrl endian (2017-07-17 20:13:56 +0800)

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

- fix virtio-net ctrl offload endian
- vnet header support for variou COLO netfilters and compare thread

----------------------------------------------------------------
Jason Wang (1):
      virtio-net: fix offload ctrl endian

Michal Privoznik (1):
      virtion-net: Prefer is_power_of_2()

Zhang Chen (12):
      net: Add vnet_hdr_len arguments in NetClientState
      net/net.c: Add vnet_hdr support in SocketReadState
      net/filter-mirror.c: Introduce parameter for filter_send()
      net/filter-mirror.c: Make filter mirror support vnet support.
      net/filter-mirror.c: Add new option to enable vnet support for filter-redirector
      net/colo.c: Make vnet_hdr_len as packet property
      net/colo-compare.c: Introduce parameter for compare_chr_send()
      net/colo-compare.c: Make colo-compare support vnet_hdr_len
      net/colo.c: Add vnet packet parse feature in colo-proxy
      net/colo-compare.c: Add vnet packet's tcp/udp/icmp compare
      net/filter-rewriter.c: Make filter-rewriter support vnet_hdr_len
      docs/colo-proxy.txt: Update colo-proxy usage of net driver with vnet_header

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We add a flag to decide whether net_fill_rstate() need read
the vnet_hdr_len or not.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Suggested-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/net.h   |  9 +++++++--
 net/colo-compare.c  |  4 ++--
 net/filter-mirror.c |  2 +-
 net/net.c           | 36 ++++++++++++++++++++++++++++++++----
 net/socket.c        |  8 ++++----
 5 files changed, 46 insertions(+), 13 deletions(-)

diff --git a/include/net/net.h b/include/net/net.h
index XXXXXXX..XXXXXXX 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -XXX,XX +XXX,XX @@ typedef struct NICState {
 } NICState;
 
 struct SocketReadState {
-    int state; /* 0 = getting length, 1 = getting data */
+    /* 0 = getting length, 1 = getting vnet header length, 2 = getting data */
+    int state;
+    /* This flag decide whether to read the vnet_hdr_len field */
+    bool vnet_hdr;
     uint32_t index;
     uint32_t packet_len;
+    uint32_t vnet_hdr_len;
     uint8_t buf[NET_BUFSIZE];
     SocketReadStateFinalize *finalize;
 };
@@ -XXX,XX +XXX,XX @@ ssize_t qemu_deliver_packet_iov(NetClientState *sender,
 void print_net_client(Monitor *mon, NetClientState *nc);
 void hmp_info_network(Monitor *mon, const QDict *qdict);
 void net_socket_rs_init(SocketReadState *rs,
-                        SocketReadStateFinalize *finalize);
+                        SocketReadStateFinalize *finalize,
+                        bool vnet_hdr);
 
 /* NIC info */
 
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 void colo_compare_complete(UserCreatable *uc, Error **errp)
         return;
     }
 
-    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize);
-    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize);
+    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, false);
+    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, false);
 
     g_queue_init(&s->conn_list);
 
diff --git a/net/filter-mirror.c b/net/filter-mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-mirror.c
+++ b/net/filter-mirror.c
@@ -XXX,XX +XXX,XX @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp)
         }
     }
 
-    net_socket_rs_init(&s->rs, redirector_rs_finalize);
+    net_socket_rs_init(&s->rs, redirector_rs_finalize, false);
 
     if (s->indev) {
         chr = qemu_chr_find(s->indev);
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 @@ QemuOptsList qemu_net_opts = {
 };
 
 void net_socket_rs_init(SocketReadState *rs,
-                        SocketReadStateFinalize *finalize)
+                        SocketReadStateFinalize *finalize,
+                        bool vnet_hdr)
 {
     rs->state = 0;
+    rs->vnet_hdr = vnet_hdr;
     rs->index = 0;
     rs->packet_len = 0;
+    rs->vnet_hdr_len = 0;
     memset(rs->buf, 0, sizeof(rs->buf));
     rs->finalize = finalize;
 }
@@ -XXX,XX +XXX,XX @@ int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
     unsigned int l;
 
     while (size > 0) {
-        /* reassemble a packet from the network */
-        switch (rs->state) { /* 0 = getting length, 1 = getting data */
+        /* Reassemble a packet from the network.
+         * 0 = getting length.
+         * 1 = getting vnet header length.
+         * 2 = getting data.
+         */
+        switch (rs->state) {
         case 0:
             l = 4 - rs->index;
             if (l > size) {
@@ -XXX,XX +XXX,XX @@ int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)
                 /* got length */
                 rs->packet_len = ntohl(*(uint32_t *)rs->buf);
                 rs->index = 0;
-                rs->state = 1;
+                if (rs->vnet_hdr) {
+                    rs->state = 1;
+                } else {
+                    rs->state = 2;
+                    rs->vnet_hdr_len = 0;
+                }
             }
             break;
         case 1:
+            l = 4 - rs->index;
+            if (l > size) {
+                l = size;
+            }
+            memcpy(rs->buf + rs->index, buf, l);
+            buf += l;
+            size -= l;
+            rs->index += l;
+            if (rs->index == 4) {
+                /* got vnet header length */
+                rs->vnet_hdr_len = ntohl(*(uint32_t *)rs->buf);
+                rs->index = 0;
+                rs->state = 2;
+            }
+            break;
+        case 2:
             l = rs->packet_len - rs->index;
             if (l > size) {
                 l = size;
diff --git a/net/socket.c b/net/socket.c
index XXXXXXX..XXXXXXX 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -XXX,XX +XXX,XX @@ static void net_socket_send(void *opaque)
         closesocket(s->fd);
 
         s->fd = -1;
-        net_socket_rs_init(&s->rs, net_socket_rs_finalize);
+        net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
         s->nc.link_down = true;
         memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
 
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
     s->fd = fd;
     s->listen_fd = -1;
     s->send_fn = net_socket_send_dgram;
-    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
+    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
     net_socket_read_poll(s, true);
 
     /* mcast: save bound address as dst */
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
 
     s->fd = fd;
     s->listen_fd = -1;
-    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
+    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 
     /* Disable Nagle algorithm on TCP sockets to reduce latency */
     socket_set_nodelay(fd);
@@ -XXX,XX +XXX,XX @@ static int net_socket_listen_init(NetClientState *peer,
     s->fd = -1;
     s->listen_fd = fd;
     s->nc.link_down = true;
-    net_socket_rs_init(&s->rs, net_socket_rs_finalize);
+    net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
 
     qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
     return 0;
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

This patch change the filter_send() parameter from CharBackend to MirrorState,
we can get more information like vnet_hdr(We use it to support packet with vnet_header).

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/filter-mirror.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/net/filter-mirror.c b/net/filter-mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-mirror.c
+++ b/net/filter-mirror.c
@@ -XXX,XX +XXX,XX @@ typedef struct MirrorState {
     SocketReadState rs;
 } MirrorState;
 
-static int filter_send(CharBackend *chr_out,
+static int filter_send(MirrorState *s,
                        const struct iovec *iov,
                        int iovcnt)
 {
@@ -XXX,XX +XXX,XX @@ static int filter_send(CharBackend *chr_out,
     }
 
     len = htonl(size);
-    ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)&len, sizeof(len));
+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
     if (ret != sizeof(len)) {
         goto err;
     }
 
     buf = g_malloc(size);
     iov_to_buf(iov, iovcnt, 0, buf, size);
-    ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)buf, size);
+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
     g_free(buf);
     if (ret != size) {
         goto err;
@@ -XXX,XX +XXX,XX @@ static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
     MirrorState *s = FILTER_MIRROR(nf);
     int ret;
 
-    ret = filter_send(&s->chr_out, iov, iovcnt);
+    ret = filter_send(s, iov, iovcnt);
     if (ret) {
         error_report("filter mirror send failed(%s)", strerror(-ret));
     }
@@ -XXX,XX +XXX,XX @@ static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
     int ret;
 
     if (qemu_chr_fe_backend_connected(&s->chr_out)) {
-        ret = filter_send(&s->chr_out, iov, iovcnt);
+        ret = filter_send(s, iov, iovcnt);
         if (ret) {
             error_report("filter redirector send failed(%s)", strerror(-ret));
         }
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We add the vnet_hdr_support option for filter-mirror, default is disabled.
If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
You can use it for example:
-object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0,vnet_hdr_support

If it has vnet_hdr_support flag, we will change the sending packet format from
struct {int size; const uint8_t buf[];} to {int size; int vnet_hdr_len; const uint8_t buf[];}.
make other module(like colo-compare) know how to parse net packet correctly.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/filter-mirror.c | 42 +++++++++++++++++++++++++++++++++++++++++-
 qemu-options.hx     |  5 ++---
 2 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/net/filter-mirror.c b/net/filter-mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-mirror.c
+++ b/net/filter-mirror.c
@@ -XXX,XX +XXX,XX @@ typedef struct MirrorState {
     CharBackend chr_in;
     CharBackend chr_out;
     SocketReadState rs;
+    bool vnet_hdr;
 } MirrorState;
 
 static int filter_send(MirrorState *s,
                        const struct iovec *iov,
                        int iovcnt)
 {
+    NetFilterState *nf = NETFILTER(s);
     int ret = 0;
     ssize_t size = 0;
     uint32_t len = 0;
@@ -XXX,XX +XXX,XX @@ static int filter_send(MirrorState *s,
         goto err;
     }
 
+    if (s->vnet_hdr) {
+        /*
+         * If vnet_hdr = on, we send vnet header len to make other
+         * module(like colo-compare) know how to parse net
+         * packet correctly.
+         */
+        ssize_t vnet_hdr_len;
+
+        vnet_hdr_len = nf->netdev->vnet_hdr_len;
+
+        len = htonl(vnet_hdr_len);
+        ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
+        if (ret != sizeof(len)) {
+            goto err;
+        }
+    }
+
     buf = g_malloc(size);
     iov_to_buf(iov, iovcnt, 0, buf, size);
     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
@@ -XXX,XX +XXX,XX @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp)
         }
     }
 
-    net_socket_rs_init(&s->rs, redirector_rs_finalize, false);
+    net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
 
     if (s->indev) {
         chr = qemu_chr_find(s->indev);
@@ -XXX,XX +XXX,XX @@ static void filter_mirror_set_outdev(Object *obj,
     }
 }
 
+static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
+{
+    MirrorState *s = FILTER_MIRROR(obj);
+
+    return s->vnet_hdr;
+}
+
+static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
+{
+    MirrorState *s = FILTER_MIRROR(obj);
+
+    s->vnet_hdr = value;
+}
+
 static char *filter_redirector_get_outdev(Object *obj, Error **errp)
 {
     MirrorState *s = FILTER_REDIRECTOR(obj);
@@ -XXX,XX +XXX,XX @@ static void filter_redirector_set_outdev(Object *obj,
 
 static void filter_mirror_init(Object *obj)
 {
+    MirrorState *s = FILTER_MIRROR(obj);
+
     object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
                             filter_mirror_set_outdev, NULL);
+
+    s->vnet_hdr = false;
+    object_property_add_bool(obj, "vnet_hdr_support",
+                             filter_mirror_get_vnet_hdr,
+                             filter_mirror_set_vnet_hdr, NULL);
 }
 
 static void filter_redirector_init(Object *obj)
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 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
 @option{tx}: the filter is attached to the transmit queue of the netdev,
              where it will receive packets sent by the netdev.
 
-@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
+@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
 
-filter-mirror on netdev @var{netdevid},mirror net packet to chardev
-@var{chardevid}
+filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
 
 @item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},
 outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We add the vnet_hdr_support option for filter-redirector, default is disabled.
If you use virtio-net-pci net driver or other driver needs vnet_hdr, please enable it.
Because colo-compare or other modules needs the vnet_hdr_len to parse
packet, we add this new option send the len to others.
You can use it for example:
-object filter-redirector,id=r0,netdev=hn0,queue=tx,outdev=red0,vnet_hdr_support

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/filter-mirror.c | 23 +++++++++++++++++++++++
 qemu-options.hx     |  6 +++---
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/net/filter-mirror.c b/net/filter-mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-mirror.c
+++ b/net/filter-mirror.c
@@ -XXX,XX +XXX,XX @@ static void filter_redirector_set_outdev(Object *obj,
     s->outdev = g_strdup(value);
 }
 
+static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
+{
+    MirrorState *s = FILTER_REDIRECTOR(obj);
+
+    return s->vnet_hdr;
+}
+
+static void filter_redirector_set_vnet_hdr(Object *obj,
+                                           bool value,
+                                           Error **errp)
+{
+    MirrorState *s = FILTER_REDIRECTOR(obj);
+
+    s->vnet_hdr = value;
+}
+
 static void filter_mirror_init(Object *obj)
 {
     MirrorState *s = FILTER_MIRROR(obj);
@@ -XXX,XX +XXX,XX @@ static void filter_mirror_init(Object *obj)
 
 static void filter_redirector_init(Object *obj)
 {
+    MirrorState *s = FILTER_REDIRECTOR(obj);
+
     object_property_add_str(obj, "indev", filter_redirector_get_indev,
                             filter_redirector_set_indev, NULL);
     object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
                             filter_redirector_set_outdev, NULL);
+
+    s->vnet_hdr = false;
+    object_property_add_bool(obj, "vnet_hdr_support",
+                             filter_redirector_get_vnet_hdr,
+                             filter_redirector_set_vnet_hdr, NULL);
 }
 
 static void filter_mirror_fini(Object *obj)
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 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
 
 filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
 
-@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},
-outdev=@var{chardevid}[,queue=@var{all|rx|tx}]
+@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
 
 filter-redirector on netdev @var{netdevid},redirect filter's net packet to chardev
-@var{chardevid},and redirect indev's packet to filter.
+@var{chardevid},and redirect indev's packet to filter.if it has the vnet_hdr_support flag,
+filter-redirector will redirect packet with vnet_hdr_len.
 Create a filter-redirector we need to differ outdev id from indev id, id can not
 be the same. we can just use indev or outdev, but at least one of indev or outdev
 need to be specified.
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We can use this property flush and send packet with vnet_hdr_len.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c    | 8 ++++++--
 net/colo.c            | 3 ++-
 net/colo.h            | 4 +++-
 net/filter-rewriter.c | 2 +-
 4 files changed, 12 insertions(+), 5 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 *conn;
 
     if (mode == PRIMARY_IN) {
-        pkt = packet_new(s->pri_rs.buf, s->pri_rs.packet_len);
+        pkt = packet_new(s->pri_rs.buf,
+                         s->pri_rs.packet_len,
+                         s->pri_rs.vnet_hdr_len);
     } else {
-        pkt = packet_new(s->sec_rs.buf, s->sec_rs.packet_len);
+        pkt = packet_new(s->sec_rs.buf,
+                         s->sec_rs.packet_len,
+                         s->sec_rs.vnet_hdr_len);
     }
 
     if (parse_packet_early(pkt)) {
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 @@ void connection_destroy(void *opaque)
     g_slice_free(Connection, conn);
 }
 
-Packet *packet_new(const void *data, int size)
+Packet *packet_new(const void *data, int size, int vnet_hdr_len)
 {
     Packet *pkt = g_slice_new(Packet);
 
     pkt->data = g_memdup(data, size);
     pkt->size = size;
     pkt->creation_ms = qemu_clock_get_ms(QEMU_CLOCK_HOST);
+    pkt->vnet_hdr_len = vnet_hdr_len;
 
     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 {
     int size;
     /* Time of packet creation, in wall clock ms */
     int64_t creation_ms;
+    /* Get vnet_hdr_len from filter */
+    uint32_t vnet_hdr_len;
 } Packet;
 
 typedef struct ConnectionKey {
@@ -XXX,XX +XXX,XX @@ Connection *connection_get(GHashTable *connection_track_table,
                            ConnectionKey *key,
                            GQueue *conn_list);
 void connection_hashtable_reset(GHashTable *connection_track_table);
-Packet *packet_new(const void *data, int size);
+Packet *packet_new(const void *data, int size, int vnet_hdr_len);
 void packet_destroy(void *opaque, void *user_data);
 
 #endif /* QEMU_COLO_PROXY_H */
diff --git a/net/filter-rewriter.c b/net/filter-rewriter.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-rewriter.c
+++ b/net/filter-rewriter.c
@@ -XXX,XX +XXX,XX @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
     char *buf = g_malloc0(size);
 
     iov_to_buf(iov, iovcnt, 0, buf, size);
-    pkt = packet_new(buf, size);
+    pkt = packet_new(buf, size, 0);
     g_free(buf);
 
     /*
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

This patch change the compare_chr_send() parameter from CharBackend to CompareState,
we can get more information like vnet_hdr(We use it to support packet with vnet_header).

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 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 @@ enum {
     SECONDARY_IN,
 };
 
-static int compare_chr_send(CharBackend *out,
+static int compare_chr_send(CompareState *s,
                             const uint8_t *buf,
                             uint32_t size);
 
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
         }
 
         if (result) {
-            ret = compare_chr_send(&s->chr_out, pkt->data, pkt->size);
+            ret = compare_chr_send(s, pkt->data, pkt->size);
             if (ret < 0) {
                 error_report("colo_send_primary_packet failed");
             }
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
     }
 }
 
-static int compare_chr_send(CharBackend *out,
+static int compare_chr_send(CompareState *s,
                             const uint8_t *buf,
                             uint32_t size)
 {
@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CharBackend *out,
         return 0;
     }
 
-    ret = qemu_chr_fe_write_all(out, (uint8_t *)&len, sizeof(len));
+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
     if (ret != sizeof(len)) {
         goto err;
     }
 
-    ret = qemu_chr_fe_write_all(out, (uint8_t *)buf, size);
+    ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
     if (ret != size) {
         goto err;
     }
@@ -XXX,XX +XXX,XX @@ static void compare_pri_rs_finalize(SocketReadState *pri_rs)
 
     if (packet_enqueue(s, PRIMARY_IN)) {
         trace_colo_compare_main("primary: unsupported packet in");
-        compare_chr_send(&s->chr_out, pri_rs->buf, pri_rs->packet_len);
+        compare_chr_send(s, pri_rs->buf, pri_rs->packet_len);
     } else {
         /* compare connection */
         g_queue_foreach(&s->conn_list, colo_compare_connection, s);
@@ -XXX,XX +XXX,XX @@ static void colo_flush_packets(void *opaque, void *user_data)
 
     while (!g_queue_is_empty(&conn->primary_list)) {
         pkt = g_queue_pop_head(&conn->primary_list);
-        compare_chr_send(&s->chr_out, pkt->data, pkt->size);
+        compare_chr_send(s, pkt->data, pkt->size);
         packet_destroy(pkt, NULL);
     }
     while (!g_queue_is_empty(&conn->secondary_list)) {
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We add the vnet_hdr_support option for colo-compare, default is disabled.
If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
You can use it for example:
-object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,outdev=compare_out0,vnet_hdr_support

COLO-compare can get vnet header length from filter,
Add vnet_hdr_len to struct packet and output packet with
the vnet_hdr_len.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-------
 qemu-options.hx    |  4 ++--
 2 files changed, 55 insertions(+), 9 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 @@ typedef struct CompareState {
     CharBackend chr_out;
     SocketReadState pri_rs;
     SocketReadState sec_rs;
+    bool vnet_hdr;
 
     /* connection list: the connections belonged to this NIC could be found
      * in this list.
@@ -XXX,XX +XXX,XX @@ enum {
 
 static int compare_chr_send(CompareState *s,
                             const uint8_t *buf,
-                            uint32_t size);
+                            uint32_t size,
+                            uint32_t vnet_hdr_len);
 
 static gint seq_sorter(Packet *a, Packet *b, gpointer data)
 {
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
         }
 
         if (result) {
-            ret = compare_chr_send(s, pkt->data, pkt->size);
+            ret = compare_chr_send(s,
+                                   pkt->data,
+                                   pkt->size,
+                                   pkt->vnet_hdr_len);
             if (ret < 0) {
                 error_report("colo_send_primary_packet failed");
             }
@@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data)
 
 static int compare_chr_send(CompareState *s,
                             const uint8_t *buf,
-                            uint32_t size)
+                            uint32_t size,
+                            uint32_t vnet_hdr_len)
 {
     int ret = 0;
     uint32_t len = htonl(size);
@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CompareState *s,
         goto err;
     }
 
+    if (s->vnet_hdr) {
+        /*
+         * We send vnet header len make other module(like filter-redirector)
+         * know how to parse net packet correctly.
+         */
+        len = htonl(vnet_hdr_len);
+        ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
+        if (ret != sizeof(len)) {
+            goto err;
+        }
+    }
+
     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
     if (ret != size) {
         goto err;
@@ -XXX,XX +XXX,XX @@ static void compare_set_outdev(Object *obj, const char *value, Error **errp)
     s->outdev = g_strdup(value);
 }
 
+static bool compare_get_vnet_hdr(Object *obj, Error **errp)
+{
+    CompareState *s = COLO_COMPARE(obj);
+
+    return s->vnet_hdr;
+}
+
+static void compare_set_vnet_hdr(Object *obj,
+                                 bool value,
+                                 Error **errp)
+{
+    CompareState *s = COLO_COMPARE(obj);
+
+    s->vnet_hdr = value;
+}
+
 static void compare_pri_rs_finalize(SocketReadState *pri_rs)
 {
     CompareState *s = container_of(pri_rs, CompareState, pri_rs);
 
     if (packet_enqueue(s, PRIMARY_IN)) {
         trace_colo_compare_main("primary: unsupported packet in");
-        compare_chr_send(s, pri_rs->buf, pri_rs->packet_len);
+        compare_chr_send(s,
+                         pri_rs->buf,
+                         pri_rs->packet_len,
+                         pri_rs->vnet_hdr_len);
     } else {
         /* compare connection */
         g_queue_foreach(&s->conn_list, colo_compare_connection, s);
@@ -XXX,XX +XXX,XX @@ static void colo_compare_complete(UserCreatable *uc, Error **errp)
         return;
     }
 
-    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, false);
-    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, false);
+    net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, s->vnet_hdr);
+    net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, s->vnet_hdr);
 
     g_queue_init(&s->conn_list);
 
@@ -XXX,XX +XXX,XX @@ static void colo_flush_packets(void *opaque, void *user_data)
 
     while (!g_queue_is_empty(&conn->primary_list)) {
         pkt = g_queue_pop_head(&conn->primary_list);
-        compare_chr_send(s, pkt->data, pkt->size);
+        compare_chr_send(s,
+                         pkt->data,
+                         pkt->size,
+                         pkt->vnet_hdr_len);
         packet_destroy(pkt, NULL);
     }
     while (!g_queue_is_empty(&conn->secondary_list)) {
@@ -XXX,XX +XXX,XX @@ static void colo_compare_class_init(ObjectClass *oc, void *data)
 
 static void colo_compare_init(Object *obj)
 {
+    CompareState *s = COLO_COMPARE(obj);
+
     object_property_add_str(obj, "primary_in",
                             compare_get_pri_indev, compare_set_pri_indev,
                             NULL);
@@ -XXX,XX +XXX,XX @@ static void colo_compare_init(Object *obj)
     object_property_add_str(obj, "outdev",
                             compare_get_outdev, compare_set_outdev,
                             NULL);
+
+    s->vnet_hdr = false;
+    object_property_add_bool(obj, "vnet_hdr_support", compare_get_vnet_hdr,
+                             compare_set_vnet_hdr, NULL);
 }
 
 static void colo_compare_finalize(Object *obj)
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 @@ Dump the network traffic on netdev @var{dev} to the file specified by
 The file format is libpcap, so it can be analyzed with tools such as tcpdump
 or Wireshark.
 
-@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},
-outdev=@var{chardevid}
+@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},outdev=@var{chardevid}[,vnet_hdr_support]
 
 Colo-compare gets packet from primary_in@var{chardevid} and secondary_in@var{chardevid}, than compare primary packet with
 secondary packet. If the packets are same, we will output primary
 packet to outdev@var{chardevid}, else we will notify colo-frame
 do checkpoint and send primary packet to outdev@var{chardevid}.
+if it has the vnet_hdr_support flag, colo compare will send/recv packet with vnet_hdr_len.
 
 we must use it with the help of filter-mirror and filter-redirector.
 
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

Make colo-compare and filter-rewriter can parse vnet packet.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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 @@ int parse_packet_early(Packet *pkt)
 {
     int network_length;
     static const uint8_t vlan[] = {0x81, 0x00};
-    uint8_t *data = pkt->data;
+    uint8_t *data = pkt->data + pkt->vnet_hdr_len;
     uint16_t l3_proto;
     ssize_t l2hdr_len = eth_get_l2_hdr_length(data);
 
-    if (pkt->size < ETH_HLEN) {
+    if (pkt->size < ETH_HLEN + pkt->vnet_hdr_len) {
         trace_colo_proxy_main("pkt->size < ETH_HLEN");
         return 1;
     }
@@ -XXX,XX +XXX,XX @@ int parse_packet_early(Packet *pkt)
     }
 
     network_length = pkt->ip->ip_hl * 4;
-    if (pkt->size < l2hdr_len + network_length) {
+    if (pkt->size < l2hdr_len + network_length + pkt->vnet_hdr_len) {
         trace_colo_proxy_main("pkt->size < network_header + network_length");
         return 1;
     }
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

COLO-Proxy just focus on packet payload, so we skip vnet header.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 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 colo_packet_compare_common(Packet *ppkt, Packet *spkt, int offset)
                                    sec_ip_src, sec_ip_dst);
     }
 
+    offset = ppkt->vnet_hdr_len + offset;
+
     if (ppkt->size == spkt->size) {
-        return memcmp(ppkt->data + offset, spkt->data + offset,
+        return memcmp(ppkt->data + offset,
+                      spkt->data + offset,
                       spkt->size - offset);
     } else {
         trace_colo_compare_main("Net packet size are not the same");
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
      */
     if (ptcp->th_off > 5) {
         ptrdiff_t tcp_offset;
+
         tcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
-                     + (ptcp->th_off * 4);
+                     + (ptcp->th_off * 4) - ppkt->vnet_hdr_len;
         res = colo_packet_compare_common(ppkt, spkt, tcp_offset);
     } else if (ptcp->th_sum == stcp->th_sum) {
         res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN);
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

We add the vnet_hdr_support option for filter-rewriter, default is disabled.
If you use virtio-net-pci or other driver needs vnet_hdr, please enable it.
You can use it for example:
-object filter-rewriter,id=rew0,netdev=hn0,queue=all,vnet_hdr_support

We get the vnet_hdr_len from NetClientState that make us
parse net packet correctly.

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/filter-rewriter.c | 37 ++++++++++++++++++++++++++++++++++++-
 qemu-options.hx       |  4 ++--
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/net/filter-rewriter.c b/net/filter-rewriter.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter-rewriter.c
+++ b/net/filter-rewriter.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu-common.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qerror.h"
+#include "qemu/error-report.h"
 #include "qapi-visit.h"
 #include "qom/object.h"
 #include "qemu/main-loop.h"
@@ -XXX,XX +XXX,XX @@ typedef struct RewriterState {
     NetQueue *incoming_queue;
     /* hashtable to save connection */
     GHashTable *connection_track_table;
+    bool vnet_hdr;
 } RewriterState;
 
 static void filter_rewriter_flush(NetFilterState *nf)
@@ -XXX,XX +XXX,XX @@ static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
     ConnectionKey key;
     Packet *pkt;
     ssize_t size = iov_size(iov, iovcnt);
+    ssize_t vnet_hdr_len = 0;
     char *buf = g_malloc0(size);
 
     iov_to_buf(iov, iovcnt, 0, buf, size);
-    pkt = packet_new(buf, size, 0);
+
+    if (s->vnet_hdr) {
+        vnet_hdr_len = nf->netdev->vnet_hdr_len;
+    }
+
+    pkt = packet_new(buf, size, vnet_hdr_len);
     g_free(buf);
 
     /*
@@ -XXX,XX +XXX,XX @@ static void colo_rewriter_setup(NetFilterState *nf, Error **errp)
     s->incoming_queue = qemu_new_net_queue(qemu_netfilter_pass_to_next, nf);
 }
 
+static bool filter_rewriter_get_vnet_hdr(Object *obj, Error **errp)
+{
+    RewriterState *s = FILTER_COLO_REWRITER(obj);
+
+    return s->vnet_hdr;
+}
+
+static void filter_rewriter_set_vnet_hdr(Object *obj,
+                                         bool value,
+                                         Error **errp)
+{
+    RewriterState *s = FILTER_COLO_REWRITER(obj);
+
+    s->vnet_hdr = value;
+}
+
+static void filter_rewriter_init(Object *obj)
+{
+    RewriterState *s = FILTER_COLO_REWRITER(obj);
+
+    s->vnet_hdr = false;
+    object_property_add_bool(obj, "vnet_hdr_support",
+                             filter_rewriter_get_vnet_hdr,
+                             filter_rewriter_set_vnet_hdr, NULL);
+}
+
 static void colo_rewriter_class_init(ObjectClass *oc, void *data)
 {
     NetFilterClass *nfc = NETFILTER_CLASS(oc);
@@ -XXX,XX +XXX,XX @@ static const TypeInfo colo_rewriter_info = {
     .name = TYPE_FILTER_REWRITER,
     .parent = TYPE_NETFILTER,
     .class_init = colo_rewriter_class_init,
+    .instance_init = filter_rewriter_init,
     .instance_size = sizeof(RewriterState),
 };
 
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 @@ Create a filter-redirector we need to differ outdev id from indev id, id can not
 be the same. we can just use indev or outdev, but at least one of indev or outdev
 need to be specified.
 
-@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid}[,queue=@var{all|rx|tx}]
+@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support]
 
 Filter-rewriter is a part of COLO project.It will rewrite tcp packet to
 secondary from primary to keep secondary tcp connection,and rewrite
 tcp packet to primary from secondary make tcp packet can be handled by
-client.
+client.if it has the vnet_hdr_support flag, we can parse packet with vnet header.
 
 usage:
 colo secondary:
-- 
2.7.4

From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>

Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 docs/colo-proxy.txt | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/docs/colo-proxy.txt b/docs/colo-proxy.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/colo-proxy.txt
+++ b/docs/colo-proxy.txt
@@ -XXX,XX +XXX,XX @@ Secondary(ip:3.3.3.8):
 -chardev socket,id=red1,host=3.3.3.3,port=9004
 -object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0
 -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1
+-object filter-rewriter,id=f3,netdev=hn0,queue=all
+
+If you want to use virtio-net-pci or other driver with vnet_header:
+
+Primary(ip:3.3.3.3):
+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown
+-device e1000,id=e0,netdev=hn0,mac=52:a4:00:12:78:66
+-chardev socket,id=mirror0,host=3.3.3.3,port=9003,server,nowait
+-chardev socket,id=compare1,host=3.3.3.3,port=9004,server,nowait
+-chardev socket,id=compare0,host=3.3.3.3,port=9001,server,nowait
+-chardev socket,id=compare0-0,host=3.3.3.3,port=9001
+-chardev socket,id=compare_out,host=3.3.3.3,port=9005,server,nowait
+-chardev socket,id=compare_out0,host=3.3.3.3,port=9005
+-object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0,vnet_hdr_support
+-object filter-redirector,netdev=hn0,id=redire0,queue=rx,indev=compare_out,vnet_hdr_support
+-object filter-redirector,netdev=hn0,id=redire1,queue=rx,outdev=compare0,vnet_hdr_support
+-object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,outdev=compare_out0,vnet_hdr_support
+
+Secondary(ip:3.3.3.8):
+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,down script=/etc/qemu-ifdown
+-device e1000,netdev=hn0,mac=52:a4:00:12:78:66
+-chardev socket,id=red0,host=3.3.3.3,port=9003
+-chardev socket,id=red1,host=3.3.3.3,port=9004
+-object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0,vnet_hdr_support
+-object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1,vnet_hdr_support
+-object filter-rewriter,id=f3,netdev=hn0,queue=all,vnet_hdr_support
 
 Note:
   a.COLO-proxy must work with COLO-frame and Block-replication.
-- 
2.7.4

From: Michal Privoznik <mprivozn@redhat.com>

We have a function that checks if given number is power of two.
We should prefer it instead of expanding the check on our own.

Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/virtio-net.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
      */
     if (n->net_conf.rx_queue_size < VIRTIO_NET_RX_QUEUE_MIN_SIZE ||
         n->net_conf.rx_queue_size > VIRTQUEUE_MAX_SIZE ||
-        (n->net_conf.rx_queue_size & (n->net_conf.rx_queue_size - 1))) {
+        !is_power_of_2(n->net_conf.rx_queue_size)) {
         error_setg(errp, "Invalid rx_queue_size (= %" PRIu16 "), "
                    "must be a power of 2 between %d and %d.",
                    n->net_conf.rx_queue_size, VIRTIO_NET_RX_QUEUE_MIN_SIZE,
-- 
2.7.4

The following changes since commit e0175b71638cf4398903c0d25f93fe62e0606389:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200228' into staging (2020-02-28 16:39:27 +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 41aa2e3f9b27fd259a13711545d933a20f1d2f16:

l2tpv3: fix RFC number typo in qemu-options.hx (2020-03-02 15:30:08 +0800)

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

----------------------------------------------------------------
Bin Meng (1):
      hw: net: cadence_gem: Fix build errors in DB_PRINT()

Finn Thain (14):
      dp8393x: Mask EOL bit from descriptor addresses
      dp8393x: Always use 32-bit accesses
      dp8393x: Clean up endianness hacks
      dp8393x: Have dp8393x_receive() return the packet size
      dp8393x: Update LLFA and CRDA registers from rx descriptor
      dp8393x: Clear RRRA command register bit only when appropriate
      dp8393x: Implement packet size limit and RBAE interrupt
      dp8393x: Don't clobber packet checksum
      dp8393x: Use long-word-aligned RRA pointers in 32-bit mode
      dp8393x: Pad frames to word or long word boundary
      dp8393x: Clear descriptor in_use field to release packet
      dp8393x: Always update RRA pointers and sequence numbers
      dp8393x: Don't reset Silicon Revision register
      dp8393x: Don't stop reception upon RBE interrupt assertion

Lukas Straub (4):
      block/replication.c: Ignore requests after failover
      tests/test-replication.c: Add test for for secondary node continuing replication
      net/filter.c: Add Options to insert filters anywhere in the filter list
      colo: Update Documentation for continuous replication

Stefan Hajnoczi (1):
      l2tpv3: fix RFC number typo in qemu-options.hx

Yuri Benditovich (3):
      e1000e: Avoid hw_error if legacy mode used
      NetRxPkt: Introduce support for additional hash types
      NetRxPkt: fix hash calculation of IPV6 TCP

From: Finn Thain <fthain@telegraphics.com.au>

The Least Significant bit of a descriptor address register is used as
an EOL flag. It has to be masked when the register value is to be used
as an actual address for copying memory around. But when the registers
are to be updated the EOL bit should not be masked.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
---
 hw/net/dp8393x.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ do { printf("sonic ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
 #define SONIC_ISR_PINT   0x0800
 #define SONIC_ISR_LCD    0x1000
 
+#define SONIC_DESC_EOL   0x0001
+#define SONIC_DESC_ADDR  0xFFFE
+
 #define TYPE_DP8393X "dp8393x"
 #define DP8393X(obj) OBJECT_CHECK(dp8393xState, (obj), TYPE_DP8393X)
 
@@ -XXX,XX +XXX,XX @@ static uint32_t dp8393x_crba(dp8393xState *s)
 
 static uint32_t dp8393x_crda(dp8393xState *s)
 {
-    return (s->regs[SONIC_URDA] << 16) | s->regs[SONIC_CRDA];
+    return (s->regs[SONIC_URDA] << 16) |
+           (s->regs[SONIC_CRDA] & SONIC_DESC_ADDR);
 }
 
 static uint32_t dp8393x_rbwc(dp8393xState *s)
@@ -XXX,XX +XXX,XX @@ static uint32_t dp8393x_tsa(dp8393xState *s)
 
 static uint32_t dp8393x_ttda(dp8393xState *s)
 {
-    return (s->regs[SONIC_UTDA] << 16) | s->regs[SONIC_TTDA];
+    return (s->regs[SONIC_UTDA] << 16) |
+           (s->regs[SONIC_TTDA] & SONIC_DESC_ADDR);
 }
 
 static uint32_t dp8393x_wt(dp8393xState *s)
@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_transmit_packets(dp8393xState *s)
                                MEMTXATTRS_UNSPECIFIED, s->data,
                                size);
             s->regs[SONIC_CTDA] = dp8393x_get(s, width, 0) & ~0x1;
-            if (dp8393x_get(s, width, 0) & 0x1) {
+            if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
                 /* EOL detected */
                 break;
             }
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     /* XXX: Check byte ordering */
 
     /* Check for EOL */
-    if (s->regs[SONIC_LLFA] & 0x1) {
+    if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
         /* Are we still in resource exhaustion? */
         size = sizeof(uint16_t) * 1 * width;
         address = dp8393x_crda(s) + sizeof(uint16_t) * 5 * width;
         address_space_read(&s->as, address, MEMTXATTRS_UNSPECIFIED,
                            s->data, size);
-        if (dp8393x_get(s, width, 0) & 0x1) {
+        if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
             /* Still EOL ; stop reception */
             return -1;
         } else {
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
                        dp8393x_crda(s) + sizeof(uint16_t) * 5 * width,
                        MEMTXATTRS_UNSPECIFIED, s->data, size);
     s->regs[SONIC_LLFA] = dp8393x_get(s, width, 0);
-    if (s->regs[SONIC_LLFA] & 0x1) {
+    if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
         /* EOL detected */
         s->regs[SONIC_ISR] |= SONIC_ISR_RDE;
     } else {
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

The DP83932 and DP83934 have 32 data lines. The datasheet says,

Data Bus: These bidirectional lines are used to transfer data on the
    system bus. When the SONIC is a bus master, 16-bit data is transferred
    on D15-D0 and 32-bit data is transferred on D31-D0. When the SONIC is
    accessed as a slave, register data is driven onto lines D15-D0.
    D31-D16 are held TRI-STATE if SONIC is in 16-bit mode. If SONIC is in
    32-bit mode, they are driven, but invalid.

Always use 32-bit accesses both as bus master and bus slave.

Force the MSW to zero in bus master mode.

This gets the Linux 'jazzsonic' driver working, and avoids the need for
prior hacks to make the NetBSD 'sn' driver work.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 47 +++++++++++++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static void dp8393x_put(dp8393xState *s, int width, int offset,
                         uint16_t val)
 {
     if (s->big_endian) {
-        s->data[offset * width + width - 1] = cpu_to_be16(val);
+        if (width == 2) {
+            s->data[offset * 2] = 0;
+            s->data[offset * 2 + 1] = cpu_to_be16(val);
+        } else {
+            s->data[offset] = cpu_to_be16(val);
+        }
     } else {
-        s->data[offset * width] = cpu_to_le16(val);
+        if (width == 2) {
+            s->data[offset * 2] = cpu_to_le16(val);
+            s->data[offset * 2 + 1] = 0;
+        } else {
+            s->data[offset] = cpu_to_le16(val);
+        }
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static uint64_t dp8393x_read(void *opaque, hwaddr addr, unsigned int size)
 
     DPRINTF("read 0x%04x from reg %s\n", val, reg_names[reg]);
 
-    return val;
+    return s->big_endian ? val << 16 : val;
 }
 
 static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
 {
     dp8393xState *s = opaque;
     int reg = addr >> s->it_shift;
+    uint32_t val = s->big_endian ? data >> 16 : data;
 
-    DPRINTF("write 0x%04x to reg %s\n", (uint16_t)data, reg_names[reg]);
+    DPRINTF("write 0x%04x to reg %s\n", (uint16_t)val, reg_names[reg]);
 
     switch (reg) {
         /* Command register */
         case SONIC_CR:
-            dp8393x_do_command(s, data);
+            dp8393x_do_command(s, val);
             break;
         /* Prevent write to read-only registers */
         case SONIC_CAP2:
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
         /* Accept write to some registers only when in reset mode */
         case SONIC_DCR:
             if (s->regs[SONIC_CR] & SONIC_CR_RST) {
-                s->regs[reg] = data & 0xbfff;
+                s->regs[reg] = val & 0xbfff;
             } else {
                 DPRINTF("writing to DCR invalid\n");
             }
             break;
         case SONIC_DCR2:
             if (s->regs[SONIC_CR] & SONIC_CR_RST) {
-                s->regs[reg] = data & 0xf017;
+                s->regs[reg] = val & 0xf017;
             } else {
                 DPRINTF("writing to DCR2 invalid\n");
             }
             break;
         /* 12 lower bytes are Read Only */
         case SONIC_TCR:
-            s->regs[reg] = data & 0xf000;
+            s->regs[reg] = val & 0xf000;
             break;
         /* 9 lower bytes are Read Only */
         case SONIC_RCR:
-            s->regs[reg] = data & 0xffe0;
+            s->regs[reg] = val & 0xffe0;
             break;
         /* Ignore most significant bit */
         case SONIC_IMR:
-            s->regs[reg] = data & 0x7fff;
+            s->regs[reg] = val & 0x7fff;
             dp8393x_update_irq(s);
             break;
         /* Clear bits by writing 1 to them */
         case SONIC_ISR:
-            data &= s->regs[reg];
-            s->regs[reg] &= ~data;
-            if (data & SONIC_ISR_RBE) {
+            val &= s->regs[reg];
+            s->regs[reg] &= ~val;
+            if (val & SONIC_ISR_RBE) {
                 dp8393x_do_read_rra(s);
             }
             dp8393x_update_irq(s);
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
         case SONIC_REA:
         case SONIC_RRP:
         case SONIC_RWP:
-            s->regs[reg] = data & 0xfffe;
+            s->regs[reg] = val & 0xfffe;
             break;
         /* Invert written value for some registers */
         case SONIC_CRCT:
         case SONIC_FAET:
         case SONIC_MPT:
-            s->regs[reg] = data ^ 0xffff;
+            s->regs[reg] = val ^ 0xffff;
             break;
         /* All other registers have no special contrainst */
         default:
-            s->regs[reg] = data;
+            s->regs[reg] = val;
     }
 
     if (reg == SONIC_WT0 || reg == SONIC_WT1) {
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
 static const MemoryRegionOps dp8393x_ops = {
     .read = dp8393x_read,
     .write = dp8393x_write,
-    .impl.min_access_size = 2,
-    .impl.max_access_size = 2,
+    .impl.min_access_size = 4,
+    .impl.max_access_size = 4,
     .endianness = DEVICE_NATIVE_ENDIAN,
 };
 
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

According to the datasheet, section 3.4.4, "in 32-bit mode ... the SONIC
always writes long words".

Therefore, use the same technique for the 'in_use' field that is used
everywhere else, and write the full long word.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         return -1;
     }
 
-    /* XXX: Check byte ordering */
-
     /* Check for EOL */
     if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
         /* Are we still in resource exhaustion? */
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         /* EOL detected */
         s->regs[SONIC_ISR] |= SONIC_ISR_RDE;
     } else {
-        /* Clear in_use, but it is always 16bit wide */
-        int offset = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
-        if (s->big_endian && width == 2) {
-            /* we need to adjust the offset of the 16bit field */
-            offset += sizeof(uint16_t);
-        }
-        s->data[0] = 0;
-        address_space_write(&s->as, offset, MEMTXATTRS_UNSPECIFIED,
-                            s->data, sizeof(uint16_t));
+        /* Clear in_use */
+        size = sizeof(uint16_t) * width;
+        address = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
+        dp8393x_put(s, width, 0, 0);
+        address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                            s->data, size);
         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
         s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

This function re-uses its 'size' argument as a scratch variable.
Instead, declare a local 'size' variable for that purpose so that the
function result doesn't get messed up.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
 }
 
 static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
-                               size_t size)
+                               size_t pkt_size)
 {
     dp8393xState *s = qemu_get_nic_opaque(nc);
     int packet_type;
     uint32_t available, address;
-    int width, rx_len = size;
+    int width, rx_len = pkt_size;
     uint32_t checksum;
+    int size;
 
     width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
 
     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
 
-    packet_type = dp8393x_receive_filter(s, buf, size);
+    packet_type = dp8393x_receive_filter(s, buf, pkt_size);
     if (packet_type < 0) {
         DPRINTF("packet not for netcard\n");
         return -1;
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     /* Done */
     dp8393x_update_irq(s);
 
-    return size;
+    return pkt_size;
 }
 
 static void dp8393x_reset(DeviceState *dev)
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

Follow the algorithm given in the National Semiconductor DP83932C
datasheet in section 3.4.7:

At the next reception, the SONIC re-reads the last RXpkt.link field,
    and updates its CRDA register to point to the next descriptor.

The chip is designed to allow the host to provide a new list of
descriptors in this way.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         address = dp8393x_crda(s) + sizeof(uint16_t) * 5 * width;
         address_space_read(&s->as, address, MEMTXATTRS_UNSPECIFIED,
                            s->data, size);
-        if (dp8393x_get(s, width, 0) & SONIC_DESC_EOL) {
+        s->regs[SONIC_LLFA] = dp8393x_get(s, width, 0);
+        if (s->regs[SONIC_LLFA] & SONIC_DESC_EOL) {
             /* Still EOL ; stop reception */
             return -1;
-        } else {
-            s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
         }
+        /* Link has been updated by host */
+        s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
     }
 
     /* Save current position */
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
                         MEMTXATTRS_UNSPECIFIED,
                         s->data, size);
 
-    /* Move to next descriptor */
+    /* Check link field */
     size = sizeof(uint16_t) * width;
     address_space_read(&s->as,
                        dp8393x_crda(s) + sizeof(uint16_t) * 5 * width,
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         dp8393x_put(s, width, 0, 0);
         address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
                             s->data, size);
+
+        /* Move to next descriptor */
         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
         s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

It doesn't make sense to clear the command register bit unless the
command was actually issued.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_read_rra(dp8393xState *s)
         s->regs[SONIC_ISR] |= SONIC_ISR_RBE;
         dp8393x_update_irq(s);
     }
-
-    /* Done */
-    s->regs[SONIC_CR] &= ~SONIC_CR_RRRA;
 }
 
 static void dp8393x_do_software_reset(dp8393xState *s)
@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_command(dp8393xState *s, uint16_t command)
         dp8393x_do_start_timer(s);
     if (command & SONIC_CR_RST)
         dp8393x_do_software_reset(s);
-    if (command & SONIC_CR_RRRA)
+    if (command & SONIC_CR_RRRA) {
         dp8393x_do_read_rra(s);
+        s->regs[SONIC_CR] &= ~SONIC_CR_RRRA;
+    }
     if (command & SONIC_CR_LCAM)
         dp8393x_do_load_cam(s);
 }
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

Add a bounds check to prevent a large packet from causing a buffer
overflow. This is defensive programming -- I haven't actually tried
sending an oversized packet or a jumbo ethernet frame.

The SONIC handles packets that are too big for the buffer by raising
the RBAE interrupt and dropping them. Linux uses that interrupt to
count dropped packets.

From: Finn Thain <fthain@telegraphics.com.au>

A received packet consumes pkt_size bytes in the buffer and the frame
checksum that's appended to it consumes another 4 bytes. The Receive
Buffer Address register takes the former quantity into account but
not the latter. So the next packet written to the buffer overwrites
the frame checksum. Fix this.

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     address += rx_len;
     address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
                         &checksum, 4);
+    address += 4;
     rx_len += 4;
     s->regs[SONIC_CRBA1] = address >> 16;
     s->regs[SONIC_CRBA0] = address & 0xffff;
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

Section 3.4.1 of the datasheet says,

The alignment of the RRA is confined to either word or long word
    boundaries, depending upon the data width mode. In 16-bit mode,
    the RRA must be aligned to a word boundary (A0 is always zero)
    and in 32-bit mode, the RRA is aligned to a long word boundary
    (A0 and A1 are always zero).

This constraint has been implemented for 16-bit mode; implement it
for 32-bit mode too.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
                 qemu_flush_queued_packets(qemu_get_queue(s->nic));
             }
             break;
-        /* Ignore least significant bit */
+        /* The guest is required to store aligned pointers here */
         case SONIC_RSA:
         case SONIC_REA:
         case SONIC_RRP:
         case SONIC_RWP:
-            s->regs[reg] = val & 0xfffe;
+            if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
+                s->regs[reg] = val & 0xfffc;
+            } else {
+                s->regs[reg] = val & 0xfffe;
+            }
             break;
         /* Invert written value for some registers */
         case SONIC_CRCT:
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

The existing code has a bug where the Remaining Buffer Word Count (RBWC)
is calculated with a truncating division, which gives the wrong result
for odd-sized packets.

Section 1.4.1 of the datasheet says,

Once the end of the packet has been reached, the serializer will
    fill out the last word (16-bit mode) or long word (32-bit mode)
    if the last byte did not end on a word or long word boundary
    respectively. The fill byte will be 0FFh.

Implement buffer padding so that buffer limits are correctly enforced.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 39 ++++++++++++++++++++++++++++-----------
 1 file changed, 28 insertions(+), 11 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     dp8393xState *s = qemu_get_nic_opaque(nc);
     int packet_type;
     uint32_t available, address;
-    int width, rx_len = pkt_size;
+    int width, rx_len, padded_len;
     uint32_t checksum;
     int size;
 
-    width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
-
     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
 
-    if (pkt_size + 4 > dp8393x_rbwc(s) * 2) {
+    rx_len = pkt_size + sizeof(checksum);
+    if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
+        width = 2;
+        padded_len = ((rx_len - 1) | 3) + 1;
+    } else {
+        width = 1;
+        padded_len = ((rx_len - 1) | 1) + 1;
+    }
+
+    if (padded_len > dp8393x_rbwc(s) * 2) {
         DPRINTF("oversize packet, pkt_size is %d\n", pkt_size);
         s->regs[SONIC_ISR] |= SONIC_ISR_RBAE;
         dp8393x_update_irq(s);
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     s->regs[SONIC_TRBA0] = s->regs[SONIC_CRBA0];
 
     /* Calculate the ethernet checksum */
-    checksum = cpu_to_le32(crc32(0, buf, rx_len));
+    checksum = cpu_to_le32(crc32(0, buf, pkt_size));
 
     /* Put packet into RBA */
     DPRINTF("Receive packet at %08x\n", dp8393x_crba(s));
     address = dp8393x_crba(s);
     address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
-                        buf, rx_len);
-    address += rx_len;
+                        buf, pkt_size);
+    address += pkt_size;
+
+    /* Put frame checksum into RBA */
     address_space_write(&s->as, address, MEMTXATTRS_UNSPECIFIED,
-                        &checksum, 4);
-    address += 4;
-    rx_len += 4;
+                        &checksum, sizeof(checksum));
+    address += sizeof(checksum);
+
+    /* Pad short packets to keep pointers aligned */
+    if (rx_len < padded_len) {
+        size = padded_len - rx_len;
+        address_space_rw(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+            (uint8_t *)"\xFF\xFF\xFF", size, 1);
+        address += size;
+    }
+
     s->regs[SONIC_CRBA1] = address >> 16;
     s->regs[SONIC_CRBA0] = address & 0xffff;
     available = dp8393x_rbwc(s);
-    available -= rx_len / 2;
+    available -= padded_len >> 1;
     s->regs[SONIC_RBWC1] = available >> 16;
     s->regs[SONIC_RBWC0] = available & 0xffff;
 
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

When the SONIC receives a packet into the last available descriptor, it
retains ownership of that descriptor for as long as necessary.

Section 3.4.7 of the datasheet says,

When the system appends more descriptors, the SONIC releases ownership
    of the descriptor after writing 0000h to the RXpkt.in_use field.

The packet can now be processed by the host, so raise a PKTRX interrupt,
just like the normal case.

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
             return -1;
         }
         /* Link has been updated by host */
+
+        /* Clear in_use */
+        size = sizeof(uint16_t) * width;
+        address = dp8393x_crda(s) + sizeof(uint16_t) * 6 * width;
+        dp8393x_put(s, width, 0, 0);
+        address_space_rw(&s->as, address, MEMTXATTRS_UNSPECIFIED,
+                         (uint8_t *)s->data, size, 1);
+
+        /* Move to next descriptor */
         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+        s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
     }
 
     /* Save current position */
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

These operations need to take place regardless of whether or not
rx descriptors have been used up (that is, EOL flag was observed).

The algorithm is now the same for a packet that was withheld as for
a packet that was not.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         /* Move to next descriptor */
         s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
-        s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
+    }
 
-        if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
-            /* Read next RRA */
-            dp8393x_do_read_rra(s);
-        }
+    s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) |
+                         ((s->regs[SONIC_RSC] + 1) & 0x00ff);
+
+    if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
+        /* Read next RRA */
+        dp8393x_do_read_rra(s);
     }
 
     /* Done */
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

The jazzsonic driver in Linux uses the Silicon Revision register value
to probe the chip. The driver fails unless the SR register contains 4.
Unfortunately, reading this register in QEMU usually returns 0 because
the s->regs[] array gets wiped after a software reset.

Fixes: bd8f1ebce4 ("net/dp8393x: fix hardware reset")
Suggested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ static void dp8393x_reset(DeviceState *dev)
     timer_del(s->watchdog);
 
     memset(s->regs, 0, sizeof(s->regs));
+    s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux/mips */
     s->regs[SONIC_CR] = SONIC_CR_RST | SONIC_CR_STP | SONIC_CR_RXDIS;
     s->regs[SONIC_DCR] &= ~(SONIC_DCR_EXBUS | SONIC_DCR_LBR);
     s->regs[SONIC_RCR] &= ~(SONIC_RCR_LB0 | SONIC_RCR_LB1 | SONIC_RCR_BRD | SONIC_RCR_RNT);
@@ -XXX,XX +XXX,XX @@ static void dp8393x_realize(DeviceState *dev, Error **errp)
     qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
 
     s->watchdog = timer_new_ns(QEMU_CLOCK_VIRTUAL, dp8393x_watchdog, s);
-    s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux */
 
     memory_region_init_ram(&s->prom, OBJECT(dev),
                            "dp8393x-prom", SONIC_PROM_SIZE, &local_err);
-- 
2.5.0

From: Finn Thain <fthain@telegraphics.com.au>

Section 3.4.7 of the datasheet explains that,

The RBE bit in the Interrupt Status register is set when the
    SONIC finishes using the second to last receive buffer and reads
    the last RRA descriptor. Actually, the SONIC is not truly out of
    resources, but gives the system an early warning of an impending
    out of resources condition.

RBE does not mean actual receive buffer exhaustion, and reception should
not be stopped. This is important because Linux will not check and clear
the RBE interrupt until it receives another packet. But that won't
happen if can_receive returns false. This bug causes the SONIC to become
deaf (until reset).

Fix this with a new flag to indicate actual receive buffer exhaustion.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Tested-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/dp8393x.c | 35 ++++++++++++++++++++++-------------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -XXX,XX +XXX,XX @@ typedef struct dp8393xState {
     /* Hardware */
     uint8_t it_shift;
     bool big_endian;
+    bool last_rba_is_full;
     qemu_irq irq;
 #ifdef DEBUG_SONIC
     int irq_level;
@@ -XXX,XX +XXX,XX @@ static void dp8393x_do_read_rra(dp8393xState *s)
         s->regs[SONIC_RRP] = s->regs[SONIC_RSA];
     }
 
-    /* Check resource exhaustion */
+    /* Warn the host if CRBA now has the last available resource */
     if (s->regs[SONIC_RRP] == s->regs[SONIC_RWP])
     {
         s->regs[SONIC_ISR] |= SONIC_ISR_RBE;
         dp8393x_update_irq(s);
     }
+
+    /* Allow packet reception */
+    s->last_rba_is_full = false;
 }
 
 static void dp8393x_do_software_reset(dp8393xState *s)
@@ -XXX,XX +XXX,XX @@ static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
                 dp8393x_do_read_rra(s);
             }
             dp8393x_update_irq(s);
-            if (dp8393x_can_receive(s->nic->ncs)) {
-                qemu_flush_queued_packets(qemu_get_queue(s->nic));
-            }
             break;
         /* The guest is required to store aligned pointers here */
         case SONIC_RSA:
@@ -XXX,XX +XXX,XX @@ static int dp8393x_can_receive(NetClientState *nc)
 
     if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
         return 0;
-    if (s->regs[SONIC_ISR] & SONIC_ISR_RBE)
-        return 0;
     return 1;
 }
 
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
     s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
         SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
 
+    if (s->last_rba_is_full) {
+        return pkt_size;
+    }
+
     rx_len = pkt_size + sizeof(checksum);
     if (s->regs[SONIC_DCR] & SONIC_DCR_DW) {
         width = 2;
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         DPRINTF("oversize packet, pkt_size is %d\n", pkt_size);
         s->regs[SONIC_ISR] |= SONIC_ISR_RBAE;
         dp8393x_update_irq(s);
-        dp8393x_do_read_rra(s);
-        return pkt_size;
+        s->regs[SONIC_RCR] |= SONIC_RCR_LPKT;
+        goto done;
     }
 
     packet_type = dp8393x_receive_filter(s, buf, pkt_size);
@@ -XXX,XX +XXX,XX @@ static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
         s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
     }
 
+    dp8393x_update_irq(s);
+
     s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) |
                          ((s->regs[SONIC_RSC] + 1) & 0x00ff);
 
+done:
+
     if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
-        /* Read next RRA */
-        dp8393x_do_read_rra(s);
+        if (s->regs[SONIC_RRP] == s->regs[SONIC_RWP]) {
+            /* Stop packet reception */
+            s->last_rba_is_full = true;
+        } else {
+            /* Read next resource */
+            dp8393x_do_read_rra(s);
+        }
     }
 
-    /* Done */
-    dp8393x_update_irq(s);
-
     return pkt_size;
 }
 
-- 
2.5.0

From: Yuri Benditovich <yuri.benditovich@daynix.com>

https://bugzilla.redhat.com/show_bug.cgi?id=1787142
The emulation issues hw_error if PSRCTL register
is written, for example, with zero value.
Such configuration does not present any problem when
DTYP bits of RCTL register define legacy format of
transfer descriptors. Current commit discards check
for BSIZE0 and BSIZE1 when legacy mode used.

Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000e_core.c | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000e_core.c
+++ b/hw/net/e1000e_core.c
@@ -XXX,XX +XXX,XX @@ e1000e_set_eitr(E1000ECore *core, int index, uint32_t val)
 static void
 e1000e_set_psrctl(E1000ECore *core, int index, uint32_t val)
 {
-    if ((val & E1000_PSRCTL_BSIZE0_MASK) == 0) {
-        hw_error("e1000e: PSRCTL.BSIZE0 cannot be zero");
-    }
+    if (core->mac[RCTL] & E1000_RCTL_DTYP_MASK) {
+
+        if ((val & E1000_PSRCTL_BSIZE0_MASK) == 0) {
+            hw_error("e1000e: PSRCTL.BSIZE0 cannot be zero");
+        }
 
-    if ((val & E1000_PSRCTL_BSIZE1_MASK) == 0) {
-        hw_error("e1000e: PSRCTL.BSIZE1 cannot be zero");
+        if ((val & E1000_PSRCTL_BSIZE1_MASK) == 0) {
+            hw_error("e1000e: PSRCTL.BSIZE1 cannot be zero");
+        }
     }
 
     core->mac[PSRCTL] = val;
-- 
2.5.0

From: Yuri Benditovich <yuri.benditovich@daynix.com>

Add support for following hash types:
IPV6 TCP with extension headers
IPV4 UDP
IPV6 UDP
IPV6 UDP with extension headers

Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/net_rx_pkt.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 hw/net/net_rx_pkt.h |  6 +++++-
 hw/net/trace-events |  4 ++++
 3 files changed, 51 insertions(+), 1 deletion(-)

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_rss_prepare_tcp(uint8_t *rss_input,
                           &tcphdr->th_dport, sizeof(uint16_t));
 }
 
+static inline void
+_net_rx_rss_prepare_udp(uint8_t *rss_input,
+                        struct NetRxPkt *pkt,
+                        size_t *bytes_written)
+{
+    struct udp_header *udphdr = &pkt->l4hdr_info.hdr.udp;
+
+    _net_rx_rss_add_chunk(rss_input, bytes_written,
+                          &udphdr->uh_sport, sizeof(uint16_t));
+
+    _net_rx_rss_add_chunk(rss_input, bytes_written,
+                          &udphdr->uh_dport, sizeof(uint16_t));
+}
+
 uint32_t
 net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
                          NetRxPktRssType type,
@@ -XXX,XX +XXX,XX @@ net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
         trace_net_rx_pkt_rss_ip6_ex();
         _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
         break;
+    case NetPktRssIpV6TcpEx:
+        assert(pkt->isip6);
+        assert(pkt->istcp);
+        trace_net_rx_pkt_rss_ip6_ex_tcp();
+        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
+        _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
+        break;
+    case NetPktRssIpV4Udp:
+        assert(pkt->isip4);
+        assert(pkt->isudp);
+        trace_net_rx_pkt_rss_ip4_udp();
+        _net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
+        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
+        break;
+    case NetPktRssIpV6Udp:
+        assert(pkt->isip6);
+        assert(pkt->isudp);
+        trace_net_rx_pkt_rss_ip6_udp();
+        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
+        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
+        break;
+    case NetPktRssIpV6UdpEx:
+        assert(pkt->isip6);
+        assert(pkt->isudp);
+        trace_net_rx_pkt_rss_ip6_ex_udp();
+        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
+        _net_rx_rss_prepare_udp(&rss_input[0], pkt, &rss_length);
+        break;
     default:
         assert(false);
         break;
diff --git a/hw/net/net_rx_pkt.h b/hw/net/net_rx_pkt.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/net_rx_pkt.h
+++ b/hw/net/net_rx_pkt.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
     NetPktRssIpV4Tcp,
     NetPktRssIpV6Tcp,
     NetPktRssIpV6,
-    NetPktRssIpV6Ex
+    NetPktRssIpV6Ex,
+    NetPktRssIpV6TcpEx,
+    NetPktRssIpV4Udp,
+    NetPktRssIpV6Udp,
+    NetPktRssIpV6UdpEx,
 } NetRxPktRssType;
 
 /**
diff --git a/hw/net/trace-events b/hw/net/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/trace-events
+++ b/hw/net/trace-events
@@ -XXX,XX +XXX,XX @@ net_rx_pkt_l3_csum_validate_csum(size_t l3hdr_off, uint32_t csl, uint32_t cntr,
 
 net_rx_pkt_rss_ip4(void) "Calculating IPv4 RSS  hash"
 net_rx_pkt_rss_ip4_tcp(void) "Calculating IPv4/TCP RSS  hash"
+net_rx_pkt_rss_ip4_udp(void) "Calculating IPv4/UDP RSS  hash"
 net_rx_pkt_rss_ip6_tcp(void) "Calculating IPv6/TCP RSS  hash"
+net_rx_pkt_rss_ip6_udp(void) "Calculating IPv6/UDP RSS  hash"
 net_rx_pkt_rss_ip6(void) "Calculating IPv6 RSS  hash"
 net_rx_pkt_rss_ip6_ex(void) "Calculating IPv6/EX RSS  hash"
+net_rx_pkt_rss_ip6_ex_tcp(void) "Calculating IPv6/EX/TCP RSS  hash"
+net_rx_pkt_rss_ip6_ex_udp(void) "Calculating IPv6/EX/UDP RSS  hash"
 net_rx_pkt_rss_hash(size_t rss_length, uint32_t rss_hash) "RSS hash for %zu bytes: 0x%X"
 net_rx_pkt_rss_add_chunk(void* ptr, size_t size, size_t input_offset) "Add RSS chunk %p, %zu bytes, RSS input offset %zu bytes"
 
-- 
2.5.0

From: Yuri Benditovich <yuri.benditovich@daynix.com>

When requested to calculate the hash for TCPV6 packet,
ignore overrides of source and destination addresses
in in extension headers.
Use these overrides when new hash type NetPktRssIpV6TcpEx
requested.
Use this type in e1000e hash calculation for IPv6 TCP, which
should take in account overrides of the addresses.

Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com>
Acked-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000e_core.c | 2 +-
 hw/net/net_rx_pkt.c  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000e_core.c
+++ b/hw/net/e1000e_core.c
@@ -XXX,XX +XXX,XX @@ e1000e_rss_calc_hash(E1000ECore *core,
         type = NetPktRssIpV4Tcp;
         break;
     case E1000_MRQ_RSS_TYPE_IPV6TCP:
-        type = NetPktRssIpV6Tcp;
+        type = NetPktRssIpV6TcpEx;
         break;
     case E1000_MRQ_RSS_TYPE_IPV6:
         type = NetPktRssIpV6;
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_rss_hash(struct NetRxPkt *pkt,
         assert(pkt->isip6);
         assert(pkt->istcp);
         trace_net_rx_pkt_rss_ip6_tcp();
-        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
+        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
         _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
         break;
     case NetPktRssIpV6:
-- 
2.5.0

From: Bin Meng <bmeng.cn@gmail.com>

When CADENCE_GEM_ERR_DEBUG is turned on, there are several
compilation errors in DB_PRINT(). Fix them.

While we are here, update to use appropriate modifiers in
the same DB_PRINT() call.

Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/cadence_gem.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/cadence_gem.c
+++ b/hw/net/cadence_gem.c
@@ -XXX,XX +XXX,XX @@ static ssize_t gem_receive(NetClientState *nc, const uint8_t *buf, size_t size)
             return -1;
         }
 
-        DB_PRINT("copy %d bytes to 0x%x\n", MIN(bytes_to_copy, rxbufsize),
-                rx_desc_get_buffer(s->rx_desc[q]));
+        DB_PRINT("copy %u bytes to 0x%" PRIx64 "\n",
+                 MIN(bytes_to_copy, rxbufsize),
+                 rx_desc_get_buffer(s, s->rx_desc[q]));
 
         /* Copy packet data to emulated DMA buffer */
         address_space_write(&s->dma_as, rx_desc_get_buffer(s, s->rx_desc[q]) +
@@ -XXX,XX +XXX,XX @@ static void gem_transmit(CadenceGEMState *s)
 
             if (tx_desc_get_length(desc) > sizeof(tx_packet) -
                                                (p - tx_packet)) {
-                DB_PRINT("TX descriptor @ 0x%x too large: size 0x%x space " \
-                         "0x%x\n", (unsigned)packet_desc_addr,
-                         (unsigned)tx_desc_get_length(desc),
+                DB_PRINT("TX descriptor @ 0x%" HWADDR_PRIx \
+                         " too large: size 0x%x space 0x%zx\n",
+                         packet_desc_addr, tx_desc_get_length(desc),
                          sizeof(tx_packet) - (p - tx_packet));
                 break;
             }
-- 
2.5.0

From: Lukas Straub <lukasstraub2@web.de>

After failover the Secondary side of replication shouldn't change state, because
it now functions as our primary disk.

In replication_start, replication_do_checkpoint, replication_stop, ignore
the request if current state is BLOCK_REPLICATION_DONE (sucessful failover) or
BLOCK_REPLICATION_FAILOVER (failover in progres i.e. currently merging active
and hidden images into the base image).

Signed-off-by: Lukas Straub <lukasstraub2@web.de>
Reviewed-by: Zhang Chen <chen.zhang@intel.com>
Acked-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 block/replication.c | 35 ++++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/block/replication.c b/block/replication.c
index XXXXXXX..XXXXXXX 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -XXX,XX +XXX,XX @@ static void replication_start(ReplicationState *rs, ReplicationMode mode,
     aio_context_acquire(aio_context);
     s = bs->opaque;
 
+    if (s->stage == BLOCK_REPLICATION_DONE ||
+        s->stage == BLOCK_REPLICATION_FAILOVER) {
+        /*
+         * This case happens when a secondary is promoted to primary.
+         * Ignore the request because the secondary side of replication
+         * doesn't have to do anything anymore.
+         */
+        aio_context_release(aio_context);
+        return;
+    }
+
     if (s->stage != BLOCK_REPLICATION_NONE) {
         error_setg(errp, "Block replication is running or done");
         aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ static void replication_do_checkpoint(ReplicationState *rs, Error **errp)
     aio_context_acquire(aio_context);
     s = bs->opaque;
 
+    if (s->stage == BLOCK_REPLICATION_DONE ||
+        s->stage == BLOCK_REPLICATION_FAILOVER) {
+        /*
+         * This case happens when a secondary was promoted to primary.
+         * Ignore the request because the secondary side of replication
+         * doesn't have to do anything anymore.
+         */
+        aio_context_release(aio_context);
+        return;
+    }
+
     if (s->mode == REPLICATION_MODE_SECONDARY) {
         secondary_do_checkpoint(s, errp);
     }
@@ -XXX,XX +XXX,XX @@ static void replication_get_error(ReplicationState *rs, Error **errp)
     aio_context_acquire(aio_context);
     s = bs->opaque;
 
-    if (s->stage != BLOCK_REPLICATION_RUNNING) {
+    if (s->stage == BLOCK_REPLICATION_NONE) {
         error_setg(errp, "Block replication is not running");
         aio_context_release(aio_context);
         return;
@@ -XXX,XX +XXX,XX @@ static void replication_stop(ReplicationState *rs, bool failover, Error **errp)
     aio_context_acquire(aio_context);
     s = bs->opaque;
 
+    if (s->stage == BLOCK_REPLICATION_DONE ||
+        s->stage == BLOCK_REPLICATION_FAILOVER) {
+        /*
+         * This case happens when a secondary was promoted to primary.
+         * Ignore the request because the secondary side of replication
+         * doesn't have to do anything anymore.
+         */
+        aio_context_release(aio_context);
+        return;
+    }
+
     if (s->stage != BLOCK_REPLICATION_RUNNING) {
         error_setg(errp, "Block replication is not running");
         aio_context_release(aio_context);
-- 
2.5.0

From: Lukas Straub <lukasstraub2@web.de>

This simulates the case that happens when we resume COLO after failover.

Signed-off-by: Lukas Straub <lukasstraub2@web.de>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 tests/test-replication.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/tests/test-replication.c b/tests/test-replication.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-replication.c
+++ b/tests/test-replication.c
@@ -XXX,XX +XXX,XX @@ static void test_secondary_stop(void)
     teardown_secondary();
 }
 
+static void test_secondary_continuous_replication(void)
+{
+    BlockBackend *top_blk, *local_blk;
+    Error *local_err = NULL;
+
+    top_blk = start_secondary();
+    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
+    g_assert(!local_err);
+
+    /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
+    local_blk = blk_by_name(S_LOCAL_DISK_ID);
+    test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
+
+    /* replication will backup s_local_disk to s_hidden_disk */
+    test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
+                  IMG_SIZE / 2, 0, IMG_SIZE, false);
+
+    /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
+    test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
+
+    /* do failover (active commit) */
+    replication_stop_all(true, &local_err);
+    g_assert(!local_err);
+
+    /* it should ignore all requests from now on */
+
+    /* start after failover */
+    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
+    g_assert(!local_err);
+
+    /* checkpoint */
+    replication_do_checkpoint_all(&local_err);
+    g_assert(!local_err);
+
+    /* stop */
+    replication_stop_all(true, &local_err);
+    g_assert(!local_err);
+
+    /* read from s_local_disk (0, IMG_SIZE / 2) */
+    test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
+                  0, IMG_SIZE / 2, false);
+
+
+    /* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
+    test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
+                  IMG_SIZE / 2, 0, IMG_SIZE, false);
+
+    teardown_secondary();
+}
+
 static void test_secondary_do_checkpoint(void)
 {
     BlockBackend *top_blk, *local_blk;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/replication/secondary/write", test_secondary_write);
     g_test_add_func("/replication/secondary/start", test_secondary_start);
     g_test_add_func("/replication/secondary/stop",  test_secondary_stop);
+    g_test_add_func("/replication/secondary/continuous_replication",
+                    test_secondary_continuous_replication);
     g_test_add_func("/replication/secondary/do_checkpoint",
                     test_secondary_do_checkpoint);
     g_test_add_func("/replication/secondary/get_error_all",
-- 
2.5.0

From: Lukas Straub <lukasstraub2@web.de>

To switch the Secondary to Primary, we need to insert new filters
before the filter-rewriter.

Add the options insert= and position= to be able to insert filters
anywhere in the filter list.

position should be "head" or "tail" to insert at the head or
tail of the filter list or it should be "id=<id>" to specify
the id of another filter.
insert should be either "before" or "behind" to specify where to
insert the new filter relative to the one specified with position.

Signed-off-by: Lukas Straub <lukasstraub2@web.de>
Reviewed-by: Zhang Chen <chen.zhang@intel.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/filter.h |  2 ++
 net/filter.c         | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 qemu-options.hx      | 31 +++++++++++++++---
 3 files changed, 119 insertions(+), 6 deletions(-)

diff --git a/include/net/filter.h b/include/net/filter.h
index XXXXXXX..XXXXXXX 100644
--- a/include/net/filter.h
+++ b/include/net/filter.h
@@ -XXX,XX +XXX,XX @@ struct NetFilterState {
     NetClientState *netdev;
     NetFilterDirection direction;
     bool on;
+    char *position;
+    bool insert_before_flag;
     QTAILQ_ENTRY(NetFilterState) next;
 };
 
diff --git a/net/filter.c b/net/filter.c
index XXXXXXX..XXXXXXX 100644
--- a/net/filter.c
+++ b/net/filter.c
@@ -XXX,XX +XXX,XX @@ static void netfilter_set_status(Object *obj, const char *str, Error **errp)
     }
 }
 
+static char *netfilter_get_position(Object *obj, Error **errp)
+{
+    NetFilterState *nf = NETFILTER(obj);
+
+    return g_strdup(nf->position);
+}
+
+static void netfilter_set_position(Object *obj, const char *str, Error **errp)
+{
+    NetFilterState *nf = NETFILTER(obj);
+
+    nf->position = g_strdup(str);
+}
+
+static char *netfilter_get_insert(Object *obj, Error **errp)
+{
+    NetFilterState *nf = NETFILTER(obj);
+
+    return nf->insert_before_flag ? g_strdup("before") : g_strdup("behind");
+}
+
+static void netfilter_set_insert(Object *obj, const char *str, Error **errp)
+{
+    NetFilterState *nf = NETFILTER(obj);
+
+    if (strcmp(str, "before") && strcmp(str, "behind")) {
+        error_setg(errp, "Invalid value for netfilter insert, "
+                         "should be 'before' or 'behind'");
+        return;
+    }
+
+    nf->insert_before_flag = !strcmp(str, "before");
+}
+
 static void netfilter_init(Object *obj)
 {
     NetFilterState *nf = NETFILTER(obj);
 
     nf->on = true;
+    nf->insert_before_flag = false;
+    nf->position = g_strdup("tail");
 
     object_property_add_str(obj, "netdev",
                             netfilter_get_netdev_id, netfilter_set_netdev_id,
@@ -XXX,XX +XXX,XX @@ static void netfilter_init(Object *obj)
     object_property_add_str(obj, "status",
                             netfilter_get_status, netfilter_set_status,
                             NULL);
+    object_property_add_str(obj, "position",
+                            netfilter_get_position, netfilter_set_position,
+                            NULL);
+    object_property_add_str(obj, "insert",
+                            netfilter_get_insert, netfilter_set_insert,
+                            NULL);
 }
 
 static void netfilter_complete(UserCreatable *uc, Error **errp)
 {
     NetFilterState *nf = NETFILTER(uc);
+    NetFilterState *position = NULL;
     NetClientState *ncs[MAX_QUEUE_NUM];
     NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
     int queues;
@@ -XXX,XX +XXX,XX @@ static void netfilter_complete(UserCreatable *uc, Error **errp)
         return;
     }
 
+    if (strcmp(nf->position, "head") && strcmp(nf->position, "tail")) {
+        Object *container;
+        Object *obj;
+        char *position_id;
+
+        if (!g_str_has_prefix(nf->position, "id=")) {
+            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "position",
+                       "'head', 'tail' or 'id=<id>'");
+            return;
+        }
+
+        /* get the id from the string */
+        position_id = g_strndup(nf->position + 3, strlen(nf->position) - 3);
+
+        /* Search for the position to insert before/behind */
+        container = object_get_objects_root();
+        obj = object_resolve_path_component(container, position_id);
+        if (!obj) {
+            error_setg(errp, "filter '%s' not found", position_id);
+            g_free(position_id);
+            return;
+        }
+
+        position = NETFILTER(obj);
+
+        if (position->netdev != ncs[0]) {
+            error_setg(errp, "filter '%s' belongs to a different netdev",
+                        position_id);
+            g_free(position_id);
+            return;
+        }
+
+        g_free(position_id);
+    }
+
     nf->netdev = ncs[0];
 
     if (nfc->setup) {
@@ -XXX,XX +XXX,XX @@ static void netfilter_complete(UserCreatable *uc, Error **errp)
             return;
         }
     }
-    QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
+
+    if (position) {
+        if (nf->insert_before_flag) {
+            QTAILQ_INSERT_BEFORE(position, nf, next);
+        } else {
+            QTAILQ_INSERT_AFTER(&nf->netdev->filters, position, nf, next);
+        }
+    } else if (!strcmp(nf->position, "head")) {
+        QTAILQ_INSERT_HEAD(&nf->netdev->filters, nf, next);
+    } else if (!strcmp(nf->position, "tail")) {
+        QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
+    }
 }
 
 static void netfilter_finalize(Object *obj)
@@ -XXX,XX +XXX,XX @@ static void netfilter_finalize(Object *obj)
         QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
     }
     g_free(nf->netdev_id);
+    g_free(nf->position);
 }
 
 static void default_handle_event(NetFilterState *nf, int event, Error **errp)
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 @@ applications, they can do this through this parameter. Its format is
 a gnutls priority string as described at
 @url{https://gnutls.org/manual/html_node/Priority-Strings.html}.
 
-@item -object filter-buffer,id=@var{id},netdev=@var{netdevid},interval=@var{t}[,queue=@var{all|rx|tx}][,status=@var{on|off}]
+@item -object filter-buffer,id=@var{id},netdev=@var{netdevid},interval=@var{t}[,queue=@var{all|rx|tx}][,status=@var{on|off}][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
 
 Interval @var{t} can't be 0, this filter batches the packet delivery: all
 packets arriving in a given interval on netdev @var{netdevid} are delayed
@@ -XXX,XX +XXX,XX @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter.
 @option{tx}: the filter is attached to the transmit queue of the netdev,
              where it will receive packets sent by the netdev.
 
-@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
+position @var{head|tail|id=<id>} is an option to specify where the
+filter should be inserted in the filter list. It can be applied to any
+netfilter.
+
+@option{head}: the filter is inserted at the head of the filter
+               list, before any existing filters.
+
+@option{tail}: the filter is inserted at the tail of the filter
+               list, behind any existing filters (default).
+
+@option{id=<id>}: the filter is inserted before or behind the filter
+                  specified by <id>, see the insert option below.
+
+insert @var{behind|before} is an option to specify where to insert the
+new filter relative to the one specified with position=id=<id>. It can
+be applied to any netfilter.
+
+@option{before}: insert before the specified filter.
+
+@option{behind}: insert behind the specified filter (default).
+
+@item -object filter-mirror,id=@var{id},netdev=@var{netdevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
 
 filter-mirror on netdev @var{netdevid},mirror net packet to chardev@var{chardevid}, if it has the vnet_hdr_support flag, filter-mirror will mirror packet with vnet_hdr_len.
 
-@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support]
+@item -object filter-redirector,id=@var{id},netdev=@var{netdevid},indev=@var{chardevid},outdev=@var{chardevid},queue=@var{all|rx|tx}[,vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
 
 filter-redirector on netdev @var{netdevid},redirect filter's net packet to chardev
 @var{chardevid},and redirect indev's packet to filter.if it has the vnet_hdr_support flag,
@@ -XXX,XX +XXX,XX @@ Create a filter-redirector we need to differ outdev id from indev id, id can not
 be the same. we can just use indev or outdev, but at least one of indev or outdev
 need to be specified.
 
-@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support]
+@item -object filter-rewriter,id=@var{id},netdev=@var{netdevid},queue=@var{all|rx|tx},[vnet_hdr_support][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
 
 Filter-rewriter is a part of COLO project.It will rewrite tcp packet to
 secondary from primary to keep secondary tcp connection,and rewrite
@@ -XXX,XX +XXX,XX @@ colo secondary:
 -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1
 -object filter-rewriter,id=rew0,netdev=hn0,queue=all
 
-@item -object filter-dump,id=@var{id},netdev=@var{dev}[,file=@var{filename}][,maxlen=@var{len}]
+@item -object filter-dump,id=@var{id},netdev=@var{dev}[,file=@var{filename}][,maxlen=@var{len}][,position=@var{head|tail|id=<id>}][,insert=@var{behind|before}]
 
 Dump the network traffic on netdev @var{dev} to the file specified by
 @var{filename}. At most @var{len} bytes (64k by default) per packet are stored.
-- 
2.5.0

From: Lukas Straub <lukasstraub2@web.de>

Document the qemu command-line and qmp commands for continuous replication

Signed-off-by: Lukas Straub <lukasstraub2@web.de>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 docs/COLO-FT.txt           | 224 +++++++++++++++++++++++++++++++++------------
 docs/block-replication.txt |  28 ++++--
 2 files changed, 184 insertions(+), 68 deletions(-)

diff --git a/docs/COLO-FT.txt b/docs/COLO-FT.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/COLO-FT.txt
+++ b/docs/COLO-FT.txt
@@ -XXX,XX +XXX,XX @@ The diagram just shows the main qmp command, you can get the detail
 in test procedure.
 
 == Test procedure ==
-1. Startup qemu
-Primary:
-# qemu-system-x86_64 -accel kvm -m 2048 -smp 2 -qmp stdio -name primary \
-  -device piix3-usb-uhci -vnc :7 \
-  -device usb-tablet -netdev tap,id=hn0,vhost=off \
-  -device virtio-net-pci,id=net-pci0,netdev=hn0 \
-  -drive if=virtio,id=primary-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
-         children.0.file.filename=1.raw,\
-         children.0.driver=raw -S
-Secondary:
-# qemu-system-x86_64 -accel kvm -m 2048 -smp 2 -qmp stdio -name secondary \
-  -device piix3-usb-uhci -vnc :7 \
-  -device usb-tablet -netdev tap,id=hn0,vhost=off \
-  -device virtio-net-pci,id=net-pci0,netdev=hn0 \
-  -drive if=none,id=secondary-disk0,file.filename=1.raw,driver=raw,node-name=node0 \
-  -drive if=virtio,id=active-disk0,driver=replication,mode=secondary,\
-         file.driver=qcow2,top-id=active-disk0,\
-         file.file.filename=/mnt/ramfs/active_disk.img,\
-         file.backing.driver=qcow2,\
-         file.backing.file.filename=/mnt/ramfs/hidden_disk.img,\
-         file.backing.backing=secondary-disk0 \
-  -incoming tcp:0:8888
-
-2. On Secondary VM's QEMU monitor, issue command
+Note: Here we are running both instances on the same host for testing,
+change the IP Addresses if you want to run it on two hosts. Initally
+127.0.0.1 is the Primary Host and 127.0.0.2 is the Secondary Host.
+
+== Startup qemu ==
+1. Primary:
+Note: Initally, $imagefolder/primary.qcow2 needs to be copied to all hosts.
+You don't need to change any IP's here, because 0.0.0.0 listens on any
+interface. The chardev's with 127.0.0.1 IP's loopback to the local qemu
+instance.
+
+# imagefolder="/mnt/vms/colo-test-primary"
+
+# qemu-system-x86_64 -enable-kvm -cpu qemu64,+kvmclock -m 512 -smp 1 -qmp stdio \
+   -device piix3-usb-uhci -device usb-tablet -name primary \
+   -netdev tap,id=hn0,vhost=off,helper=/usr/lib/qemu/qemu-bridge-helper \
+   -device rtl8139,id=e0,netdev=hn0 \
+   -chardev socket,id=mirror0,host=0.0.0.0,port=9003,server,nowait \
+   -chardev socket,id=compare1,host=0.0.0.0,port=9004,server,wait \
+   -chardev socket,id=compare0,host=127.0.0.1,port=9001,server,nowait \
+   -chardev socket,id=compare0-0,host=127.0.0.1,port=9001 \
+   -chardev socket,id=compare_out,host=127.0.0.1,port=9005,server,nowait \
+   -chardev socket,id=compare_out0,host=127.0.0.1,port=9005 \
+   -object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0 \
+   -object filter-redirector,netdev=hn0,id=redire0,queue=rx,indev=compare_out \
+   -object filter-redirector,netdev=hn0,id=redire1,queue=rx,outdev=compare0 \
+   -object iothread,id=iothread1 \
+   -object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,\
+outdev=compare_out0,iothread=iothread1 \
+   -drive if=ide,id=colo-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
+children.0.file.filename=$imagefolder/primary.qcow2,children.0.driver=qcow2 -S
+
+2. Secondary:
+Note: Active and hidden images need to be created only once and the
+size should be the same as primary.qcow2. Again, you don't need to change
+any IP's here, except for the $primary_ip variable.
+
+# imagefolder="/mnt/vms/colo-test-secondary"
+# primary_ip=127.0.0.1
+
+# qemu-img create -f qcow2 $imagefolder/secondary-active.qcow2 10G
+
+# qemu-img create -f qcow2 $imagefolder/secondary-hidden.qcow2 10G
+
+# qemu-system-x86_64 -enable-kvm -cpu qemu64,+kvmclock -m 512 -smp 1 -qmp stdio \
+   -device piix3-usb-uhci -device usb-tablet -name secondary \
+   -netdev tap,id=hn0,vhost=off,helper=/usr/lib/qemu/qemu-bridge-helper \
+   -device rtl8139,id=e0,netdev=hn0 \
+   -chardev socket,id=red0,host=$primary_ip,port=9003,reconnect=1 \
+   -chardev socket,id=red1,host=$primary_ip,port=9004,reconnect=1 \
+   -object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0 \
+   -object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1 \
+   -object filter-rewriter,id=rew0,netdev=hn0,queue=all \
+   -drive if=none,id=parent0,file.filename=$imagefolder/primary.qcow2,driver=qcow2 \
+   -drive if=none,id=childs0,driver=replication,mode=secondary,file.driver=qcow2,\
+top-id=colo-disk0,file.file.filename=$imagefolder/secondary-active.qcow2,\
+file.backing.driver=qcow2,file.backing.file.filename=$imagefolder/secondary-hidden.qcow2,\
+file.backing.backing=parent0 \
+   -drive if=ide,id=colo-disk0,driver=quorum,read-pattern=fifo,vote-threshold=1,\
+children.0=childs0 \
+   -incoming tcp:0.0.0.0:9998
+
+
+3. On Secondary VM's QEMU monitor, issue command
 {'execute':'qmp_capabilities'}
-{ 'execute': 'nbd-server-start',
-  'arguments': {'addr': {'type': 'inet', 'data': {'host': 'xx.xx.xx.xx', 'port': '8889'} } }
-}
-{'execute': 'nbd-server-add', 'arguments': {'device': 'secondary-disk0', 'writable': true } }
+{'execute': 'nbd-server-start', 'arguments': {'addr': {'type': 'inet', 'data': {'host': '0.0.0.0', 'port': '9999'} } } }
+{'execute': 'nbd-server-add', 'arguments': {'device': 'parent0', 'writable': true } }
 
 Note:
   a. The qmp command nbd-server-start and nbd-server-add must be run
      before running the qmp command migrate on primary QEMU
   b. Active disk, hidden disk and nbd target's length should be the
      same.
-  c. It is better to put active disk and hidden disk in ramdisk.
+  c. It is better to put active disk and hidden disk in ramdisk. They
+     will be merged into the parent disk on failover.
 
-3. On Primary VM's QEMU monitor, issue command:
+4. On Primary VM's QEMU monitor, issue command:
 {'execute':'qmp_capabilities'}
-{ 'execute': 'human-monitor-command',
-  'arguments': {'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=xx.xx.xx.xx,file.port=8889,file.export=secondary-disk0,node-name=nbd_client0'}}
-{ 'execute':'x-blockdev-change', 'arguments':{'parent': 'primary-disk0', 'node': 'nbd_client0' } }
-{ 'execute': 'migrate-set-capabilities',
-      'arguments': {'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
-{ 'execute': 'migrate', 'arguments': {'uri': 'tcp:xx.xx.xx.xx:8888' } }
+{'execute': 'human-monitor-command', 'arguments': {'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.2,file.port=9999,file.export=parent0,node-name=replication0'}}
+{'execute': 'x-blockdev-change', 'arguments':{'parent': 'colo-disk0', 'node': 'replication0' } }
+{'execute': 'migrate-set-capabilities', 'arguments': {'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
+{'execute': 'migrate', 'arguments': {'uri': 'tcp:127.0.0.2:9998' } }
 
   Note:
   a. There should be only one NBD Client for each primary disk.
-  b. xx.xx.xx.xx is the secondary physical machine's hostname or IP
-  c. The qmp command line must be run after running qmp command line in
+  b. The qmp command line must be run after running qmp command line in
      secondary qemu.
 
-4. After the above steps, you will see, whenever you make changes to PVM, SVM will be synced.
+5. After the above steps, you will see, whenever you make changes to PVM, SVM will be synced.
 You can issue command '{ "execute": "migrate-set-parameters" , "arguments":{ "x-checkpoint-delay": 2000 } }'
-to change the checkpoint period time
+to change the idle checkpoint period time
+
+6. Failover test
+You can kill one of the VMs and Failover on the surviving VM:
+
+If you killed the Secondary, then follow "Primary Failover". After that,
+if you want to resume the replication, follow "Primary resume replication"
+
+If you killed the Primary, then follow "Secondary Failover". After that,
+if you want to resume the replication, follow "Secondary resume replication"
+
+== Primary Failover ==
+The Secondary died, resume on the Primary
+
+{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'child': 'children.1'} }
+{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_del replication0' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'comp0' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'iothread1' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'm0' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'redire0' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'redire1' } }
+{'execute': 'x-colo-lost-heartbeat' }
+
+== Secondary Failover ==
+The Primary died, resume on the Secondary and prepare to become the new Primary
+
+{'execute': 'nbd-server-stop'}
+{'execute': 'x-colo-lost-heartbeat'}
+
+{'execute': 'object-del', 'arguments':{ 'id': 'f2' } }
+{'execute': 'object-del', 'arguments':{ 'id': 'f1' } }
+{'execute': 'chardev-remove', 'arguments':{ 'id': 'red1' } }
+{'execute': 'chardev-remove', 'arguments':{ 'id': 'red0' } }
+
+{'execute': 'chardev-add', 'arguments':{ 'id': 'mirror0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '0.0.0.0', 'port': '9003' } }, 'server': true } } } }
+{'execute': 'chardev-add', 'arguments':{ 'id': 'compare1', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '0.0.0.0', 'port': '9004' } }, 'server': true } } } }
+{'execute': 'chardev-add', 'arguments':{ 'id': 'compare0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9001' } }, 'server': true } } } }
+{'execute': 'chardev-add', 'arguments':{ 'id': 'compare0-0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9001' } }, 'server': false } } } }
+{'execute': 'chardev-add', 'arguments':{ 'id': 'compare_out', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9005' } }, 'server': true } } } }
+{'execute': 'chardev-add', 'arguments':{ 'id': 'compare_out0', 'backend': {'type': 'socket', 'data': {'addr': { 'type': 'inet', 'data': { 'host': '127.0.0.1', 'port': '9005' } }, 'server': false } } } }
+
+== Primary resume replication ==
+Resume replication after new Secondary is up.
+
+Start the new Secondary (Steps 2 and 3 above), then on the Primary:
+{'execute': 'drive-mirror', 'arguments':{ 'device': 'colo-disk0', 'job-id': 'resync', 'target': 'nbd://127.0.0.2:9999/parent0', 'mode': 'existing', 'format': 'raw', 'sync': 'full'} }
+
+Wait until disk is synced, then:
+{'execute': 'stop'}
+{'execute': 'block-job-cancel', 'arguments':{ 'device': 'resync'} }
+
+{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.2,file.port=9999,file.export=parent0,node-name=replication0'}}
+{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'node': 'replication0' } }
+
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-mirror', 'id': 'm0', 'props': { 'netdev': 'hn0', 'queue': 'tx', 'outdev': 'mirror0' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire0', 'props': { 'netdev': 'hn0', 'queue': 'rx', 'indev': 'compare_out' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire1', 'props': { 'netdev': 'hn0', 'queue': 'rx', 'outdev': 'compare0' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'iothread', 'id': 'iothread1' } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'colo-compare', 'id': 'comp0', 'props': { 'primary_in': 'compare0-0', 'secondary_in': 'compare1', 'outdev': 'compare_out0', 'iothread': 'iothread1' } } }
+
+{'execute': 'migrate-set-capabilities', 'arguments':{ 'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
+{'execute': 'migrate', 'arguments':{ 'uri': 'tcp:127.0.0.2:9998' } }
+
+Note:
+If this Primary previously was a Secondary, then we need to insert the
+filters before the filter-rewriter by using the
+"'insert': 'before', 'position': 'id=rew0'" Options. See below.
+
+== Secondary resume replication ==
+Become Primary and resume replication after new Secondary is up. Note
+that now 127.0.0.1 is the Secondary and 127.0.0.2 is the Primary.
+
+Start the new Secondary (Steps 2 and 3 above, but with primary_ip=127.0.0.2),
+then on the old Secondary:
+{'execute': 'drive-mirror', 'arguments':{ 'device': 'colo-disk0', 'job-id': 'resync', 'target': 'nbd://127.0.0.1:9999/parent0', 'mode': 'existing', 'format': 'raw', 'sync': 'full'} }
+
+Wait until disk is synced, then:
+{'execute': 'stop'}
+{'execute': 'block-job-cancel', 'arguments':{ 'device': 'resync' } }
 
-5. Failover test
-You can kill Primary VM and run 'x_colo_lost_heartbeat' in Secondary VM's
-monitor at the same time, then SVM will failover and client will not detect this
-change.
+{'execute': 'human-monitor-command', 'arguments':{ 'command-line': 'drive_add -n buddy driver=replication,mode=primary,file.driver=nbd,file.host=127.0.0.1,file.port=9999,file.export=parent0,node-name=replication0'}}
+{'execute': 'x-blockdev-change', 'arguments':{ 'parent': 'colo-disk0', 'node': 'replication0' } }
 
-Before issuing '{ "execute": "x-colo-lost-heartbeat" }' command, we have to
-issue block related command to stop block replication.
-Primary:
-  Remove the nbd child from the quorum:
-  { 'execute': 'x-blockdev-change', 'arguments': {'parent': 'colo-disk0', 'child': 'children.1'}}
-  { 'execute': 'human-monitor-command','arguments': {'command-line': 'drive_del blk-buddy0'}}
-  Note: there is no qmp command to remove the blockdev now
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-mirror', 'id': 'm0', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'tx', 'outdev': 'mirror0' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire0', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'rx', 'indev': 'compare_out' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'filter-redirector', 'id': 'redire1', 'props': { 'insert': 'before', 'position': 'id=rew0', 'netdev': 'hn0', 'queue': 'rx', 'outdev': 'compare0' } } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'iothread', 'id': 'iothread1' } }
+{'execute': 'object-add', 'arguments':{ 'qom-type': 'colo-compare', 'id': 'comp0', 'props': { 'primary_in': 'compare0-0', 'secondary_in': 'compare1', 'outdev': 'compare_out0', 'iothread': 'iothread1' } } }
 
-Secondary:
-  The primary host is down, so we should do the following thing:
-  { 'execute': 'nbd-server-stop' }
+{'execute': 'migrate-set-capabilities', 'arguments':{ 'capabilities': [ {'capability': 'x-colo', 'state': true } ] } }
+{'execute': 'migrate', 'arguments':{ 'uri': 'tcp:127.0.0.1:9998' } }
 
 == TODO ==
-1. Support continuous VM replication.
-2. Support shared storage.
-3. Develop the heartbeat part.
-4. Reduce checkpoint VM’s downtime while doing checkpoint.
+1. Support shared storage.
+2. Develop the heartbeat part.
+3. Reduce checkpoint VM’s downtime while doing checkpoint.
diff --git a/docs/block-replication.txt b/docs/block-replication.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/block-replication.txt
+++ b/docs/block-replication.txt
@@ -XXX,XX +XXX,XX @@ blocks that are already in QEMU.
              ^            ||                            .----------
              |            ||                            | Secondary
         1 Quorum          ||                            '----------
-         /      \         ||
-        /        \        ||
-   Primary    2 filter
-     disk         ^                                                             virtio-blk
-                  |                                                                  ^
-                3 NBD  ------->  3 NBD                                               |
+         /      \         ||                                                           virtio-blk
+        /        \        ||                                                               ^
+   Primary    2 filter                                                                     |
+     disk         ^                                                                   7 Quorum
+                  |                                                                    /
+                3 NBD  ------->  3 NBD                                                /
                 client    ||     server                                          2 filter
                           ||        ^                                                ^
 --------.                 ||        |                                                |
@@ -XXX,XX +XXX,XX @@ any state that would otherwise be lost by the speculative write-through
 of the NBD server into the secondary disk. So before block replication,
 the primary disk and secondary disk should contain the same data.
 
+7) The secondary also has a quorum node, so after secondary failover it
+can become the new primary and continue replication.
+
+
 == Failure Handling ==
 There are 7 internal errors when block replication is running:
 1. I/O error on primary disk
@@ -XXX,XX +XXX,XX @@ Primary:
      leading whitespace.
   5. The qmp command line must be run after running qmp command line in
      secondary qemu.
-  6. After failover we need remove children.1 (replication driver).
+  6. After primary failover we need remove children.1 (replication driver).
 
 Secondary:
   -drive if=none,driver=raw,file.filename=1.raw,id=colo1 \
-  -drive if=xxx,id=topxxx,driver=replication,mode=secondary,top-id=topxxx\
+  -drive if=none,id=childs1,driver=replication,mode=secondary,top-id=childs1
          file.file.filename=active_disk.qcow2,\
          file.driver=qcow2,\
          file.backing.file.filename=hidden_disk.qcow2,\
          file.backing.driver=qcow2,\
          file.backing.backing=colo1
+  -drive if=xxx,driver=quorum,read-pattern=fifo,id=top-disk1,\
+         vote-threshold=1,children.0=childs1
 
   Then run qmp command in secondary qemu:
     { 'execute': 'nbd-server-start',
@@ -XXX,XX +XXX,XX @@ Secondary:
   The primary host is down, so we should do the following thing:
   { 'execute': 'nbd-server-stop' }
 
+Promote Secondary to Primary:
+  see COLO-FT.txt
+
 TODO:
-1. Continuous block replication
-2. Shared disk
+1. Shared disk
-- 
2.5.0

From: Stefan Hajnoczi <stefanha@redhat.com>

The L2TPv3 RFC number is 3931:
https://tools.ietf.org/html/rfc3931

Reported-by: Henrik Johansson <henrikjohansson@rocketmail.com>
Reviewed-by: Stefan Weil <sw@weilnetz.de>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 qemu-options.hx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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,
     "                Linux kernel 3.3+ as well as most routers can talk\n"
     "                L2TPv3. This transport allows connecting a VM to a VM,\n"
     "                VM to a router and even VM to Host. It is a nearly-universal\n"
-    "                standard (RFC3391). Note - this implementation uses static\n"
+    "                standard (RFC3931). Note - this implementation uses static\n"
     "                pre-configured tunnels (same as the Linux kernel).\n"
     "                use 'src=' to specify source address\n"
     "                use 'dst=' to specify destination address\n"
@@ -XXX,XX +XXX,XX @@ Example (send packets from host's 1.2.3.4):
 @end example
 
 @item -netdev l2tpv3,id=@var{id},src=@var{srcaddr},dst=@var{dstaddr}[,srcport=@var{srcport}][,dstport=@var{dstport}],txsession=@var{txsession}[,rxsession=@var{rxsession}][,ipv6][,udp][,cookie64][,counter][,pincounter][,txcookie=@var{txcookie}][,rxcookie=@var{rxcookie}][,offset=@var{offset}]
-Configure a L2TPv3 pseudowire host network backend. L2TPv3 (RFC3391) is a
+Configure a L2TPv3 pseudowire host network backend. L2TPv3 (RFC3931) is a
 popular protocol to transport Ethernet (and other Layer 2) data frames between
 two systems. It is present in routers, firewalls and the Linux kernel
 (from version 3.3 onwards).
-- 
2.5.0