Series comparison

-[Qemu-devel] [PULL 0/4] Net patches
+[Qemu-devel] [PULL V2 00/13] Net patches
-The following changes since commit a04d91c701251a9b32b7364ddb48029ba024cb75:
+The following changes since commit b6179aaff961627fcb59d7b234297966b81ac726:
-  Merge remote-tracking branch 'remotes/alistair/tags/pull-device-tree-20190327' into staging (2019-03-28 12:39:43 +0000)
+  Merge remote-tracking branch 'remotes/pmaydell/tags/pull-cocoa-20190304' into staging (2019-03-04 16:50:41 +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 ab79237a15e8f8c23310291b672d83374cf17935:
+for you to fetch changes up to 4b9b70000218640a42c3ea908a12665e5840b6cd:
-  net: tap: use qemu_set_nonblock (2019-03-29 15:22:18 +0800)
+  tests: Add a test for qemu self announcements (2019-03-05 11:27:41 +0800)
 ----------------------------------------------------------------
+Changes from V1:
+- build fixes for qmp controlled announcing
 ----------------------------------------------------------------
-Li Qiang (1):
+Dr. David Alan Gilbert (9):
-      net: tap: use qemu_set_nonblock
+      net: Introduce announce timer
       migration: Add announce parameters
       virtio-net: Switch to using announce timer
       migration: Switch to using announce timer
       net: Add a network device specific self-announcement ability
       virtio-net: Allow qemu_announce_self to trigger virtio announcements
       qmp: Add announce-self command
       hmp: Add hmp_announce_self
       tests: Add a test for qemu self announcements
-Marc-André Lureau (1):
+Vincenzo Maffione (3):
-      net/socket: learn to talk with a unix dgram socket
+      net: netmap: small improvements netmap_send()
       net: netmap: simplify netmap_receive()
       net: netmap: improve netmap_receive_iov()
 Zhang Chen (1):
-      MAINTAINERS: Update the latest email address
+      net/colo-compare.c: Remove duplicated code
-yuchenlin (1):
+ hmp-commands.hx                |  16 +++++
-      e1000: Delay flush queue when receive RCTL
+ hmp.c                          |  33 ++++++++++
+ hmp.h                          |   1 +
- MAINTAINERS    |  2 +-
+ hw/net/trace-events            |   6 ++
- hw/net/e1000.c | 24 ++++++++++++++++++++++--
+ hw/net/virtio-net.c            |  69 +++++++++++++++-----
- net/socket.c   | 25 +++++++++++++++++++++----
+ include/hw/virtio/virtio-net.h |   4 +-
- net/tap.c      | 10 +++++-----
+ include/migration/misc.h       |  12 +---
-files changed, 49 insertions(+), 12 deletions(-)
+ include/net/announce.h         |  41 ++++++++++++
  include/net/net.h              |   2 +
  include/qemu/typedefs.h        |   1 +
  include/sysemu/sysemu.h        |   2 -
  migration/migration.c          | 103 +++++++++++++++++++++++++++++-
  migration/migration.h          |   4 ++
  migration/savevm.c             |  72 +--------------------
  migration/trace-events         |   1 -
  net/Makefile.objs              |   1 +
  net/announce.c                 | 140 +++++++++++++++++++++++++++++++++++++++++
  net/colo-compare.c             |   8 ---
  net/netmap.c                   | 110 ++++++++++++++------------------
  net/trace-events               |   3 +
  qapi/migration.json            |  53 +++++++++++++++-
  qapi/net.json                  |  43 +++++++++++++
  tests/Makefile.include         |   3 +
  tests/test-announce-self.c     |  82 ++++++++++++++++++++++++
  tests/test-hmp.c               |   1 +
 files changed, 637 insertions(+), 174 deletions(-)
  create mode 100644 include/net/announce.h
  create mode 100644 net/announce.c
  create mode 100644 tests/test-announce-self.c

-[Qemu-devel] [PULL 3/4] MAINTAINERS: Update the latest email address
+[Qemu-devel] [PULL V2 01/13] net/colo-compare.c: Remove duplicated code
 From: Zhang Chen <chen.zhang@intel.com>
+Fix duplicated code:
+https://bugs.launchpad.net/qemu/+bug/1811499
+Reviewed-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Signed-off-by: Zhang Chen <chen.zhang@intel.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- MAINTAINERS | 2 +-
+ net/colo-compare.c | 8 --------
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 8 deletions(-)
-diff --git a/MAINTAINERS b/MAINTAINERS
+diff --git a/net/colo-compare.c b/net/colo-compare.c
 index XXXXXXX..XXXXXXX 100644
---- a/MAINTAINERS
+--- a/net/colo-compare.c
-+++ b/MAINTAINERS
++++ b/net/colo-compare.c
-@@ -XXX,XX +XXX,XX @@ F: include/migration/failover.h
+@@ -XXX,XX +XXX,XX @@ static bool colo_mark_tcp_pkt(Packet *ppkt, Packet *spkt,
- F: docs/COLO-FT.txt
+             return true;
+         }
- COLO Proxy
+     }
--M: Zhang Chen <zhangckid@gmail.com>
+-    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
-+M: Zhang Chen <chen.zhang@intel.com>
+-        if (colo_compare_packet_payload(ppkt, spkt,
- M: Li Zhijian <lizhijian@cn.fujitsu.com>
+-                                        ppkt->header_size, spkt->header_size,
- S: Supported
+-                                        ppkt->payload_size)) {
- F: docs/colo-proxy.txt
+-            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
 -            return true;
 -        }
 -    }
      /* one part of secondary packet payload still need to be compared */
      if (!after(ppkt->seq_end, spkt->seq_end)) {
 --
 .5.0

-New patch
+[Qemu-devel] [PULL V2 02/13] net: netmap: small improvements netmap_send()
+From: Vincenzo Maffione <v.maffione@gmail.com>
+This change improves the handling of incomplete multi-slot packets
+(e.g. with the NS_MOREFRAG set), by advancing ring->head only on
+complete packets. The ring->cur pointer is advanced in any case in
+order to acknowledge the kernel and move the wake-up point (thus
+avoiding repeated wake-ups).
+Also don't be verbose when incomplete packets are found.
+Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/netmap.c | 31 +++++++++++++++++++------------
+file changed, 19 insertions(+), 12 deletions(-)
+diff --git a/net/netmap.c b/net/netmap.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/netmap.c
++++ b/net/netmap.c
+@@ -XXX,XX +XXX,XX @@ static void netmap_send(void *opaque)
+ {
+     NetmapState *s = opaque;
+     struct netmap_ring *ring = s->rx;
++    unsigned int tail = ring->tail;
+-    /* Keep sending while there are available packets into the netmap
++    /* Keep sending while there are available slots in the netmap
+        RX ring and the forwarding path towards the peer is open. */
+-    while (!nm_ring_empty(ring)) {
+-        uint32_t i;
++    while (ring->head != tail) {
++        uint32_t i = ring->head;
+         uint32_t idx;
+         bool morefrag;
+         int iovcnt = 0;
+         int iovsize;
++        /* Get a (possibly multi-slot) packet. */
+         do {
+-            i = ring->cur;
+             idx = ring->slot[i].buf_idx;
+             morefrag = (ring->slot[i].flags & NS_MOREFRAG);
+-            s->iov[iovcnt].iov_base = (u_char *)NETMAP_BUF(ring, idx);
++            s->iov[iovcnt].iov_base = (void *)NETMAP_BUF(ring, idx);
+             s->iov[iovcnt].iov_len = ring->slot[i].len;
+             iovcnt++;
++            i = nm_ring_next(ring, i);
++        } while (i != tail && morefrag);
+-            ring->cur = ring->head = nm_ring_next(ring, i);
+-        } while (!nm_ring_empty(ring) && morefrag);
++        /* Advance ring->cur to tell the kernel that we have seen the slots. */
++        ring->cur = i;
+-        if (unlikely(nm_ring_empty(ring) && morefrag)) {
+-            RD(5, "[netmap_send] ran out of slots, with a pending"
+-                   "incomplete packet\n");
++        if (unlikely(morefrag)) {
++            /* This is a truncated packet, so we can stop without releasing the
++             * incomplete slots by updating ring->head. We will hopefully
++             * re-read the complete packet the next time we are called. */
++            break;
+         }
+         iovsize = qemu_sendv_packet_async(&s->nc, s->iov, iovcnt,
+                                             netmap_send_completed);
++        /* Release the slots to the kernel. */
++        ring->head = i;
++
+         if (iovsize == 0) {
+             /* The peer does not receive anymore. Packet is queued, stop
+-             * reading from the backend until netmap_send_completed()
+-             */
++             * reading from the backend until netmap_send_completed(). */
+             netmap_read_poll(s, false);
+             break;
+         }
+--
+.5.0

-New patch
+[Qemu-devel] [PULL V2 03/13] net: netmap: simplify netmap_receive()
+From: Vincenzo Maffione <v.maffione@gmail.com>
+Improve code reuse by implementing netmap_receive() with a call
+to netmap_receive_iov().
+Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/netmap.c | 50 +++++++++++---------------------------------------
+file changed, 11 insertions(+), 39 deletions(-)
+diff --git a/net/netmap.c b/net/netmap.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/netmap.c
++++ b/net/netmap.c
+@@ -XXX,XX +XXX,XX @@ static void netmap_writable(void *opaque)
+     qemu_flush_queued_packets(&s->nc);
+ }
+-static ssize_t netmap_receive(NetClientState *nc,
+-      const uint8_t *buf, size_t size)
+-{
+-    NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
+-    struct netmap_ring *ring = s->tx;
+-    uint32_t i;
+-    uint32_t idx;
+-    uint8_t *dst;
+-
+-    if (unlikely(!ring)) {
+-        /* Drop. */
+-        return size;
+-    }
+-
+-    if (unlikely(size > ring->nr_buf_size)) {
+-        RD(5, "[netmap_receive] drop packet of size %d > %d\n",
+-                                    (int)size, ring->nr_buf_size);
+-        return size;
+-    }
+-
+-    if (nm_ring_empty(ring)) {
+-        /* No available slots in the netmap TX ring. */
+-        netmap_write_poll(s, true);
+-        return 0;
+-    }
+-
+-    i = ring->cur;
+-    idx = ring->slot[i].buf_idx;
+-    dst = (uint8_t *)NETMAP_BUF(ring, idx);
+-
+-    ring->slot[i].len = size;
+-    ring->slot[i].flags = 0;
+-    pkt_copy(buf, dst, size);
+-    ring->cur = ring->head = nm_ring_next(ring, i);
+-    ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
+-
+-    return size;
+-}
+-
+ static ssize_t netmap_receive_iov(NetClientState *nc,
+                     const struct iovec *iov, int iovcnt)
+ {
+@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
+     return iov_size(iov, iovcnt);
+ }
++static ssize_t netmap_receive(NetClientState *nc,
++      const uint8_t *buf, size_t size)
++{
++    struct iovec iov;
++
++    iov.iov_base = (void *)buf;
++    iov.iov_len = size;
++
++    return netmap_receive_iov(nc, &iov, 1);
++}
++
+ /* Complete a previous send (backend --> guest) and enable the
+    fd_read callback. */
+ static void netmap_send_completed(NetClientState *nc, ssize_t len)
+--
+.5.0

-New patch
+[Qemu-devel] [PULL V2 04/13] net: netmap: improve netmap_receive_iov()
+From: Vincenzo Maffione <v.maffione@gmail.com>
+Changes:
+  - Save CPU cycles by computing the return value while scanning the
+    input iovec, rather than calling iov_size() at the end.
+  - Remove check for s->tx != NULL, because it cannot happen.
+  - Cache ring->tail in a local variable and use it to check for
+    space in the TX ring. The use of nm_ring_empty() was invalid,
+    because nobody is updating ring->cur and ring->head at that point.
+  - In case we run out of netmap slots in the middle of a packet,
+    move the wake-up point by advancing ring->cur, but do not
+    expose the incomplete packet (i.e., by updating also ring->head).
+Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/netmap.c | 29 +++++++++++++++++------------
+file changed, 17 insertions(+), 12 deletions(-)
+diff --git a/net/netmap.c b/net/netmap.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/netmap.c
++++ b/net/netmap.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
+ {
+     NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
+     struct netmap_ring *ring = s->tx;
++    unsigned int tail = ring->tail;
++    ssize_t totlen = 0;
+     uint32_t last;
+     uint32_t idx;
+     uint8_t *dst;
+     int j;
+     uint32_t i;
+-    if (unlikely(!ring)) {
+-        /* Drop the packet. */
+-        return iov_size(iov, iovcnt);
+-    }
+-
+-    last = i = ring->cur;
++    last = i = ring->head;
+     if (nm_ring_space(ring) < iovcnt) {
+-        /* Not enough netmap slots. */
++        /* Not enough netmap slots. Tell the kernel that we have seen the new
++         * available slots (so that it notifies us again when it has more
++         * ones), but without publishing any new slots to be processed
++         * (e.g., we don't advance ring->head). */
++        ring->cur = tail;
+         netmap_write_poll(s, true);
+         return 0;
+     }
+@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
+         int offset = 0;
+         int nm_frag_size;
++        totlen += iov_frag_size;
++
+         /* Split each iovec fragment over more netmap slots, if
+            necessary. */
+         while (iov_frag_size) {
+             nm_frag_size = MIN(iov_frag_size, ring->nr_buf_size);
+-            if (unlikely(nm_ring_empty(ring))) {
+-                /* We run out of netmap slots while splitting the
++            if (unlikely(i == tail)) {
++                /* We ran out of netmap slots while splitting the
+                    iovec fragments. */
++                ring->cur = tail;
+                 netmap_write_poll(s, true);
+                 return 0;
+             }
+@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
+     /* The last slot must not have NS_MOREFRAG set. */
+     ring->slot[last].flags &= ~NS_MOREFRAG;
+-    /* Now update ring->cur and ring->head. */
+-    ring->cur = ring->head = i;
++    /* Now update ring->head and ring->cur to publish the new slots and
++     * the new wakeup point. */
++    ring->head = ring->cur = i;
+     ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
+-    return iov_size(iov, iovcnt);
++    return totlen;
+ }
+ static ssize_t netmap_receive(NetClientState *nc,
+--
+.5.0

-New patch
+[Qemu-devel] [PULL V2 05/13] net: Introduce announce timer
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
 The 'announce timer' will be used by migration, and explicit
 requests for qemu to perform network announces.
 Based on the work by Germano Veit Michel <germano@redhat.com>
  and Vlad Yasevich <vyasevic@redhat.com>
 Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
  include/net/announce.h  | 39 ++++++++++++++++++++++++++++++++
  include/qemu/typedefs.h |  1 +
  migration/migration.c   |  1 +
  net/Makefile.objs       |  1 +
  net/announce.c          | 60 +++++++++++++++++++++++++++++++++++++++++++++++++
  qapi/net.json           | 23 +++++++++++++++++++
 files changed, 125 insertions(+)
  create mode 100644 include/net/announce.h
  create mode 100644 net/announce.c
 diff --git a/include/net/announce.h b/include/net/announce.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/net/announce.h
@@ -XXX,XX +XXX,XX @@
 +/*
 + *  Self-announce facility
 + *  (c) 2017-2019 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
 +#ifndef QEMU_NET_ANNOUNCE_H
 +#define QEMU_NET_ANNOUNCE_H
 +
 +#include "qemu-common.h"
 +#include "qapi/qapi-types-net.h"
 +#include "qemu/timer.h"
 +
 +struct AnnounceTimer {
 +    QEMUTimer *tm;
 +    AnnounceParameters params;
 +    QEMUClockType type;
 +    int round;
 +};
 +
 +/* Returns: update the timer to the next time point */
 +int64_t qemu_announce_timer_step(AnnounceTimer *timer);
 +
 +/* Delete the underlying timer */
 +void qemu_announce_timer_del(AnnounceTimer *timer);
 +
 +/*
 + * Under BQL/main thread
 + * Reset the timer to the given parameters/type/notifier.
 + */
 +void qemu_announce_timer_reset(AnnounceTimer *timer,
 +                               AnnounceParameters *params,
 +                               QEMUClockType type,
 +                               QEMUTimerCB *cb,
 +                               void *opaque);
 +
 +#endif
 diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/typedefs.h
 +++ b/include/qemu/typedefs.h
@@ -XXX,XX +XXX,XX @@
  typedef struct AdapterInfo AdapterInfo;
  typedef struct AddressSpace AddressSpace;
  typedef struct AioContext AioContext;
 +typedef struct AnnounceTimer AnnounceTimer;
  typedef struct BdrvDirtyBitmap BdrvDirtyBitmap;
  typedef struct BdrvDirtyBitmapIter BdrvDirtyBitmapIter;
  typedef struct BlockBackend BlockBackend;
 diff --git a/migration/migration.c b/migration/migration.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/migration.c
 +++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@
  #include "migration/colo.h"
  #include "hw/boards.h"
  #include "monitor/monitor.h"
 +#include "net/announce.h"
  #define MAX_THROTTLE  (32 << 20)      /* Migration transfer speed throttling */
 diff --git a/net/Makefile.objs b/net/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/net/Makefile.objs
 +++ b/net/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-y = net.o queue.o checksum.o util.o hub.o
  common-obj-y += socket.o
  common-obj-y += dump.o
  common-obj-y += eth.o
 +common-obj-y += announce.o
  common-obj-$(CONFIG_L2TPV3) += l2tpv3.o
  common-obj-$(call land,$(CONFIG_VIRTIO_NET),$(CONFIG_VHOST_NET_USER)) += vhost-user.o
  common-obj-$(call land,$(call lnot,$(CONFIG_VIRTIO_NET)),$(CONFIG_VHOST_NET_USER)) += vhost-user-stub.o
 diff --git a/net/announce.c b/net/announce.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + *  Self-announce
 + *  (c) 2017-2019 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qemu-common.h"
 +#include "net/announce.h"
 +#include "qapi/clone-visitor.h"
 +#include "qapi/qapi-visit-net.h"
 +
 +int64_t qemu_announce_timer_step(AnnounceTimer *timer)
 +{
 +    int64_t step;
 +
 +    step =  timer->params.initial +
 +            (timer->params.rounds - timer->round - 1) *
 +            timer->params.step;
 +
 +    if (step < 0 || step > timer->params.max) {
 +        step = timer->params.max;
 +    }
 +    timer_mod(timer->tm, qemu_clock_get_ms(timer->type) + step);
 +
 +    return step;
 +}
 +
 +void qemu_announce_timer_del(AnnounceTimer *timer)
 +{
 +    if (timer->tm) {
 +        timer_del(timer->tm);
 +        timer_free(timer->tm);
 +        timer->tm = NULL;
 +    }
 +}
 +
 +/*
 + * Under BQL/main thread
 + * Reset the timer to the given parameters/type/notifier.
 + */
 +void qemu_announce_timer_reset(AnnounceTimer *timer,
 +                               AnnounceParameters *params,
 +                               QEMUClockType type,
 +                               QEMUTimerCB *cb,
 +                               void *opaque)
 +{
 +    /*
 +     * We're under the BQL, so the current timer can't
 +     * be firing, so we should be able to delete it.
 +     */
 +    qemu_announce_timer_del(timer);
 +
 +    QAPI_CLONE_MEMBERS(AnnounceParameters, &timer->params, params);
 +    timer->round = params->rounds;
 +    timer->type = type;
 +    timer->tm = timer_new_ms(type, cb, opaque);
 +}
 diff --git a/qapi/net.json b/qapi/net.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/net.json
 +++ b/qapi/net.json
@@ -XXX,XX +XXX,XX @@
  ##
  { 'event': 'NIC_RX_FILTER_CHANGED',
    'data': { '*name': 'str', 'path': 'str' } }
 +
 +##
 +# @AnnounceParameters:
 +#
 +# Parameters for self-announce timers
 +#
 +# @initial: Initial delay (in ms) before sending the first GARP/RARP
 +#       announcement
 +#
 +# @max: Maximum delay (in ms) between GARP/RARP announcement packets
 +#
 +# @rounds: Number of self-announcement attempts
 +#
 +# @step: Delay increase (in ms) after each self-announcement attempt
 +#
 +# Since: 4.0
 +##
 +
 +{ 'struct': 'AnnounceParameters',
 +  'data': { 'initial': 'int',
 +            'max': 'int',
 +            'rounds': 'int',
 +            'step': 'int' } }
 --
 .5.0

-New patch
+[Qemu-devel] [PULL V2 06/13] migration: Add announce parameters
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
 Add migration parameters that control RARP/GARP announcement timeouts.
 Based on earlier patches by myself and
   Vladislav Yasevich <vyasevic@redhat.com>
 Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
  hmp.c                    |  28 +++++++++++++
  include/migration/misc.h |   2 +
  migration/migration.c    | 100 +++++++++++++++++++++++++++++++++++++++++++++++
  qapi/migration.json      |  53 +++++++++++++++++++++++--
 files changed, 180 insertions(+), 3 deletions(-)
 diff --git a/hmp.c b/hmp.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hmp.c
 +++ b/hmp.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
      params = qmp_query_migrate_parameters(NULL);
      if (params) {
 +        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 +            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL),
 +            params->announce_initial);
 +        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 +            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX),
 +            params->announce_max);
 +        monitor_printf(mon, "%s: %" PRIu64 "\n",
 +            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS),
 +            params->announce_rounds);
 +        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 +            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP),
 +            params->announce_step);
          assert(params->has_compress_level);
          monitor_printf(mon, "%s: %u\n",
              MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL),
@@ -XXX,XX +XXX,XX @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
          p->has_max_postcopy_bandwidth = true;
          visit_type_size(v, param, &p->max_postcopy_bandwidth, &err);
          break;
 +    case MIGRATION_PARAMETER_ANNOUNCE_INITIAL:
 +        p->has_announce_initial = true;
 +        visit_type_size(v, param, &p->announce_initial, &err);
 +        break;
 +    case MIGRATION_PARAMETER_ANNOUNCE_MAX:
 +        p->has_announce_max = true;
 +        visit_type_size(v, param, &p->announce_max, &err);
 +        break;
 +    case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS:
 +        p->has_announce_rounds = true;
 +        visit_type_size(v, param, &p->announce_rounds, &err);
 +        break;
 +    case MIGRATION_PARAMETER_ANNOUNCE_STEP:
 +        p->has_announce_step = true;
 +        visit_type_size(v, param, &p->announce_step, &err);
 +        break;
      default:
          assert(0);
      }
 diff --git a/include/migration/misc.h b/include/migration/misc.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/migration/misc.h
 +++ b/include/migration/misc.h
@@ -XXX,XX +XXX,XX @@
  #define MIGRATION_MISC_H
  #include "qemu/notify.h"
 +#include "qapi/qapi-types-net.h"
  /* migration/ram.c */
@@ -XXX,XX +XXX,XX @@ int64_t self_announce_delay(int round)
      return 50 + (SELF_ANNOUNCE_ROUNDS - round - 1) * 100;
  }
 +AnnounceParameters *migrate_announce_params(void);
  /* migration/savevm.c */
  void dump_vmstate_json_to_file(FILE *out_fp);
 diff --git a/migration/migration.c b/migration/migration.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/migration.c
 +++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@
   */
  #define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0
 +/*
 + * Parameters for self_announce_delay giving a stream of RARP/ARP
 + * packets after migration.
 + */
 +#define DEFAULT_MIGRATE_ANNOUNCE_INITIAL  50
 +#define DEFAULT_MIGRATE_ANNOUNCE_MAX     550
 +#define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS    5
 +#define DEFAULT_MIGRATE_ANNOUNCE_STEP    100
 +
  static NotifierList migration_state_notifiers =
      NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
@@ -XXX,XX +XXX,XX @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp)
      params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;
      params->has_max_cpu_throttle = true;
      params->max_cpu_throttle = s->parameters.max_cpu_throttle;
 +    params->has_announce_initial = true;
 +    params->announce_initial = s->parameters.announce_initial;
 +    params->has_announce_max = true;
 +    params->announce_max = s->parameters.announce_max;
 +    params->has_announce_rounds = true;
 +    params->announce_rounds = s->parameters.announce_rounds;
 +    params->has_announce_step = true;
 +    params->announce_step = s->parameters.announce_step;
      return params;
  }
 +AnnounceParameters *migrate_announce_params(void)
 +{
 +    static AnnounceParameters ap;
 +
 +    MigrationState *s = migrate_get_current();
 +
 +    ap.initial = s->parameters.announce_initial;
 +    ap.max = s->parameters.announce_max;
 +    ap.rounds = s->parameters.announce_rounds;
 +    ap.step = s->parameters.announce_step;
 +
 +    return &ap;
 +}
 +
  /*
   * Return true if we're already in the middle of a migration
   * (i.e. any of the active or setup states)
@@ -XXX,XX +XXX,XX @@ static bool migrate_params_check(MigrationParameters *params, Error **errp)
          return false;
      }
 +    if (params->has_announce_initial &&
 +        params->announce_initial > 100000) {
 +        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 +                   "announce_initial",
 +                   "is invalid, it must be less than 100000 ms");
 +        return false;
 +    }
 +    if (params->has_announce_max &&
 +        params->announce_max > 100000) {
 +        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 +                   "announce_max",
 +                   "is invalid, it must be less than 100000 ms");
 +       return false;
 +    }
 +    if (params->has_announce_rounds &&
 +        params->announce_rounds > 1000) {
 +        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 +                   "announce_rounds",
 +                   "is invalid, it must be in the range of 0 to 1000");
 +       return false;
 +    }
 +    if (params->has_announce_step &&
 +        (params->announce_step < 1 ||
 +        params->announce_step > 10000)) {
 +        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 +                   "announce_step",
 +                   "is invalid, it must be in the range of 1 to 10000 ms");
 +       return false;
 +    }
      return true;
  }
@@ -XXX,XX +XXX,XX @@ static void migrate_params_test_apply(MigrateSetParameters *params,
      if (params->has_max_cpu_throttle) {
          dest->max_cpu_throttle = params->max_cpu_throttle;
      }
 +    if (params->has_announce_initial) {
 +        dest->announce_initial = params->announce_initial;
 +    }
 +    if (params->has_announce_max) {
 +        dest->announce_max = params->announce_max;
 +    }
 +    if (params->has_announce_rounds) {
 +        dest->announce_rounds = params->announce_rounds;
 +    }
 +    if (params->has_announce_step) {
 +        dest->announce_step = params->announce_step;
 +    }
  }
  static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
      if (params->has_max_cpu_throttle) {
          s->parameters.max_cpu_throttle = params->max_cpu_throttle;
      }
 +    if (params->has_announce_initial) {
 +        s->parameters.announce_initial = params->announce_initial;
 +    }
 +    if (params->has_announce_max) {
 +        s->parameters.announce_max = params->announce_max;
 +    }
 +    if (params->has_announce_rounds) {
 +        s->parameters.announce_rounds = params->announce_rounds;
 +    }
 +    if (params->has_announce_step) {
 +        s->parameters.announce_step = params->announce_step;
 +    }
  }
  void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
@@ -XXX,XX +XXX,XX @@ static Property migration_properties[] = {
      DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,
                        parameters.max_cpu_throttle,
                        DEFAULT_MIGRATE_MAX_CPU_THROTTLE),
 +    DEFINE_PROP_SIZE("announce-initial", MigrationState,
 +                      parameters.announce_initial,
 +                      DEFAULT_MIGRATE_ANNOUNCE_INITIAL),
 +    DEFINE_PROP_SIZE("announce-max", MigrationState,
 +                      parameters.announce_max,
 +                      DEFAULT_MIGRATE_ANNOUNCE_MAX),
 +    DEFINE_PROP_SIZE("announce-rounds", MigrationState,
 +                      parameters.announce_rounds,
 +                      DEFAULT_MIGRATE_ANNOUNCE_ROUNDS),
 +    DEFINE_PROP_SIZE("announce-step", MigrationState,
 +                      parameters.announce_step,
 +                      DEFAULT_MIGRATE_ANNOUNCE_STEP),
      /* Migration capabilities */
      DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
@@ -XXX,XX +XXX,XX @@ static void migration_instance_init(Object *obj)
      params->has_xbzrle_cache_size = true;
      params->has_max_postcopy_bandwidth = true;
      params->has_max_cpu_throttle = true;
 +    params->has_announce_initial = true;
 +    params->has_announce_max = true;
 +    params->has_announce_rounds = true;
 +    params->has_announce_step = true;
      qemu_sem_init(&ms->postcopy_pause_sem, 0);
      qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);
 diff --git a/qapi/migration.json b/qapi/migration.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/migration.json
 +++ b/qapi/migration.json
@@ -XXX,XX +XXX,XX @@
  #
  # Migration parameters enumeration
  #
 +# @announce-initial: Initial delay (in milliseconds) before sending the first
 +#          announce (Since 4.0)
 +#
 +# @announce-max: Maximum delay (in milliseconds) between packets in the
 +#          announcement (Since 4.0)
 +#
 +# @announce-rounds: Number of self-announce packets sent after migration
 +#          (Since 4.0)
 +#
 +# @announce-step: Increase in delay (in milliseconds) between subsequent
 +#          packets in the announcement (Since 4.0)
 +#
  # @compress-level: Set the compression level to be used in live migration,
  #          the compression level is an integer between 0 and 9, where 0 means
  #          no compression, 1 means the best compression speed, and 9 means best
@@ -XXX,XX +XXX,XX @@
  #
  # @max-cpu-throttle: maximum cpu throttle percentage.
  #                    Defaults to 99. (Since 3.1)
 +#
  # Since: 2.4
  ##
  { 'enum': 'MigrationParameter',
 -  'data': ['compress-level', 'compress-threads', 'decompress-threads',
 +  'data': ['announce-initial', 'announce-max',
 +           'announce-rounds', 'announce-step',
 +           'compress-level', 'compress-threads', 'decompress-threads',
             'compress-wait-thread',
             'cpu-throttle-initial', 'cpu-throttle-increment',
             'tls-creds', 'tls-hostname', 'max-bandwidth',
@@ -XXX,XX +XXX,XX @@
  ##
  # @MigrateSetParameters:
  #
 +# @announce-initial: Initial delay (in milliseconds) before sending the first
 +#          announce (Since 4.0)
 +#
 +# @announce-max: Maximum delay (in milliseconds) between packets in the
 +#          announcement (Since 4.0)
 +#
 +# @announce-rounds: Number of self-announce packets sent after migration
 +#          (Since 4.0)
 +#
 +# @announce-step: Increase in delay (in milliseconds) between subsequent
 +#          packets in the announcement (Since 4.0)
 +#
  # @compress-level: compression level
  #
  # @compress-threads: compression thread count
@@ -XXX,XX +XXX,XX @@
  # TODO either fuse back into MigrationParameters, or make
  # MigrationParameters members mandatory
  { 'struct': 'MigrateSetParameters',
 -  'data': { '*compress-level': 'int',
 +  'data': { '*announce-initial': 'size',
 +            '*announce-max': 'size',
 +            '*announce-rounds': 'size',
 +            '*announce-step': 'size',
 +            '*compress-level': 'int',
              '*compress-threads': 'int',
              '*compress-wait-thread': 'bool',
              '*decompress-threads': 'int',
@@ -XXX,XX +XXX,XX @@
  #
  # The optional members aren't actually optional.
  #
 +# @announce-initial: Initial delay (in milliseconds) before sending the
 +#          first announce (Since 4.0)
 +#
 +# @announce-max: Maximum delay (in milliseconds) between packets in the
 +#          announcement (Since 4.0)
 +#
 +# @announce-rounds: Number of self-announce packets sent after migration
 +#          (Since 4.0)
 +#
 +# @announce-step: Increase in delay (in milliseconds) between subsequent
 +#          packets in the announcement (Since 4.0)
 +#
  # @compress-level: compression level
  #
  # @compress-threads: compression thread count
@@ -XXX,XX +XXX,XX @@
  # Since: 2.4
  ##
  { 'struct': 'MigrationParameters',
 -  'data': { '*compress-level': 'uint8',
 +  'data': { '*announce-initial': 'size',
 +            '*announce-max': 'size',
 +            '*announce-rounds': 'size',
 +            '*announce-step': 'size',
 +            '*compress-level': 'uint8',
              '*compress-threads': 'uint8',
              '*compress-wait-thread': 'bool',
              '*decompress-threads': 'uint8',
 --
 .5.0

-[Qemu-devel] [PULL 4/4] net: tap: use qemu_set_nonblock
+[Qemu-devel] [PULL V2 07/13] virtio-net: Switch to using announce timer
-From: Li Qiang <liq3ea@gmail.com>
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
-The fcntl will change the flags directly, use qemu_set_nonblock()
+Switch virtio's self announcement to use the AnnounceTimer.
-instead.
+It keeps it's own AnnounceTimer (per device), and starts running it
 using a migration post-load and a virtual clock; that way the
 announce happens once the guest is actually running.
 The timer uses the migration parameters to set the timing of
 the repeats.
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Based on earlier patches by myself and
-Acked-by: Michael S. Tsirkin <mst@redhat.com>
+ Vladislav Yasevich <vyasevic@redhat.com>
-Signed-off-by: Li Qiang <liq3ea@gmail.com>
 Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/tap.c | 10 +++++-----
+ hw/net/trace-events            |  5 +++++
-file changed, 5 insertions(+), 5 deletions(-)
+ hw/net/virtio-net.c            | 36 +++++++++++++++++++++++-------------
  include/hw/virtio/virtio-net.h |  4 ++--
 files changed, 30 insertions(+), 15 deletions(-)
-diff --git a/net/tap.c b/net/tap.c
+diff --git a/hw/net/trace-events b/hw/net/trace-events
 index XXXXXXX..XXXXXXX 100644
---- a/net/tap.c
+--- a/hw/net/trace-events
-+++ b/net/tap.c
++++ b/hw/net/trace-events
-@@ -XXX,XX +XXX,XX @@ int net_init_bridge(const Netdev *netdev, const char *name,
+@@ -XXX,XX +XXX,XX @@ sunhme_rx_filter_reject(void) "rejecting incoming frame"
-         return -1;
+ sunhme_rx_filter_accept(void) "accepting incoming frame"
  sunhme_rx_desc(uint32_t addr, int offset, uint32_t status, int len, int cr, int nr) "addr 0x%"PRIx32"(+0x%x) status 0x%"PRIx32 " len %d (ring %d/%d)"
  sunhme_rx_xsum_calc(uint16_t xsum) "calculated incoming xsum as 0x%x"
 +
 +# hw/net/virtio-net.c
 +virtio_net_announce_timer(int round) "%d"
 +virtio_net_handle_announce(int round) "%d"
 +virtio_net_post_load_device(void)
 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 @@
  #include "qemu/timer.h"
  #include "hw/virtio/virtio-net.h"
  #include "net/vhost_net.h"
 +#include "net/announce.h"
  #include "hw/virtio/virtio-bus.h"
  #include "qapi/error.h"
  #include "qapi/qapi-events-net.h"
  #include "hw/virtio/virtio-access.h"
  #include "migration/misc.h"
  #include "standard-headers/linux/ethtool.h"
 +#include "trace.h"
  #define VIRTIO_NET_VM_VERSION    11
@@ -XXX,XX +XXX,XX @@ static void virtio_net_announce_timer(void *opaque)
  {
      VirtIONet *n = opaque;
      VirtIODevice *vdev = VIRTIO_DEVICE(n);
 +    trace_virtio_net_announce_timer(n->announce_timer.round);
 -    n->announce_counter--;
 +    n->announce_timer.round--;
      n->status |= VIRTIO_NET_S_ANNOUNCE;
      virtio_notify_config(vdev);
  }
@@ -XXX,XX +XXX,XX @@ static void virtio_net_reset(VirtIODevice *vdev)
      n->nobcast = 0;
      /* multiqueue is disabled by default */
      n->curr_queues = 1;
 -    timer_del(n->announce_timer);
 -    n->announce_counter = 0;
 +    timer_del(n->announce_timer.tm);
 +    n->announce_timer.round = 0;
      n->status &= ~VIRTIO_NET_S_ANNOUNCE;
      /* Flush any MAC and VLAN filter table state */
@@ -XXX,XX +XXX,XX @@ static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
  static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
                                        struct iovec *iov, unsigned int iov_cnt)
  {
 +    trace_virtio_net_handle_announce(n->announce_timer.round);
      if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
          n->status & VIRTIO_NET_S_ANNOUNCE) {
          n->status &= ~VIRTIO_NET_S_ANNOUNCE;
 -        if (n->announce_counter) {
 -            timer_mod(n->announce_timer,
 -                      qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 -                      self_announce_delay(n->announce_counter));
 +        if (n->announce_timer.round) {
 +            qemu_announce_timer_step(&n->announce_timer);
          }
          return VIRTIO_NET_OK;
      } else {
@@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id)
      VirtIODevice *vdev = VIRTIO_DEVICE(n);
      int i, link_down;
 +    trace_virtio_net_post_load_device();
      virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
                                 virtio_vdev_has_feature(vdev,
                                                         VIRTIO_F_VERSION_1));
@@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id)
      if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
          virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
 -        n->announce_counter = SELF_ANNOUNCE_ROUNDS;
 -        timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));
 +        qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
 +                                  QEMU_CLOCK_VIRTUAL,
 +                                  virtio_net_announce_timer, n);
 +        if (n->announce_timer.round) {
 +            timer_mod(n->announce_timer.tm,
 +                      qemu_clock_get_ms(n->announce_timer.type));
 +        } else {
 +            qemu_announce_timer_del(&n->announce_timer);
 +        }
      }
--    fcntl(fd, F_SETFL, O_NONBLOCK);
+     return 0;
-+    qemu_set_nonblock(fd);
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
-     vnet_hdr = tap_probe_vnet_hdr(fd);
+     qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
-     s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
+     memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
+     n->status = VIRTIO_NET_S_LINK_UP;
-@@ -XXX,XX +XXX,XX @@ static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
+-    n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
-                 }
+-                                     virtio_net_announce_timer, n);
-                 return;
++    qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
-             }
++                              QEMU_CLOCK_VIRTUAL,
--            fcntl(vhostfd, F_SETFL, O_NONBLOCK);
++                              virtio_net_announce_timer, n);
-+            qemu_set_nonblock(vhostfd);
-         }
+     if (n->netclient_type) {
-         options.opaque = (void *)(uintptr_t)vhostfd;
+         /*
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
-@@ -XXX,XX +XXX,XX @@ int net_init_tap(const Netdev *netdev, const char *name,
+         virtio_net_del_queue(n, i);
-             return -1;
+     }
-         }
+-    timer_del(n->announce_timer);
--        fcntl(fd, F_SETFL, O_NONBLOCK);
+-    timer_free(n->announce_timer);
-+        qemu_set_nonblock(fd);
++    qemu_announce_timer_del(&n->announce_timer);
+     g_free(n->vqs);
-         vnet_hdr = tap_probe_vnet_hdr(fd);
+     qemu_del_nic(n->nic);
+     virtio_net_rsc_cleanup(n);
-@@ -XXX,XX +XXX,XX @@ int net_init_tap(const Netdev *netdev, const char *name,
+diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h
-                 goto free_fail;
+index XXXXXXX..XXXXXXX 100644
-             }
+--- a/include/hw/virtio/virtio-net.h
++++ b/include/hw/virtio/virtio-net.h
--            fcntl(fd, F_SETFL, O_NONBLOCK);
+@@ -XXX,XX +XXX,XX @@
-+            qemu_set_nonblock(fd);
+ #include "qemu/units.h"
+ #include "standard-headers/linux/virtio_net.h"
-             if (i == 0) {
+ #include "hw/virtio/virtio.h"
-                 vnet_hdr = tap_probe_vnet_hdr(fd);
++#include "net/announce.h"
-@@ -XXX,XX +XXX,XX @@ free_fail:
-             return -1;
+ #define TYPE_VIRTIO_NET "virtio-net-device"
-         }
+ #define VIRTIO_NET(obj) \
+@@ -XXX,XX +XXX,XX @@ struct VirtIONet {
--        fcntl(fd, F_SETFL, O_NONBLOCK);
+     char *netclient_name;
-+        qemu_set_nonblock(fd);
+     char *netclient_type;
-         vnet_hdr = tap_probe_vnet_hdr(fd);
+     uint64_t curr_guest_offloads;
+-    QEMUTimer *announce_timer;
-         net_init_tap_one(tap, peer, "bridge", name, ifname,
+-    int announce_counter;
 +    AnnounceTimer announce_timer;
      bool needs_vnet_hdr_swap;
      bool mtu_bypass_backend;
  };
 --
 .5.0

-New patch
+[Qemu-devel] [PULL V2 08/13] migration: Switch to using announce timer
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
 Switch the announcements to using the new announce timer.
 Move the code that does it to announce.c rather than savevm
 because it really has nothing to do with the actual migration.
 Migration starts the announce from bh's and so they're all
 in the main thread/bql, and so there's never any racing with
 the timers themselves.
 Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
  include/migration/misc.h | 10 -------
  include/net/announce.h   |  2 ++
  include/sysemu/sysemu.h  |  2 --
  migration/migration.c    |  2 +-
  migration/migration.h    |  4 +++
  migration/savevm.c       | 72 ++----------------------------------------------
  migration/trace-events   |  1 -
  net/announce.c           | 68 +++++++++++++++++++++++++++++++++++++++++++++
  net/trace-events         |  3 ++
 files changed, 81 insertions(+), 83 deletions(-)
 diff --git a/include/migration/misc.h b/include/migration/misc.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/migration/misc.h
 +++ b/include/migration/misc.h
@@ -XXX,XX +XXX,XX @@ void blk_mig_init(void);
  static inline void blk_mig_init(void) {}
  #endif
 -#define SELF_ANNOUNCE_ROUNDS 5
 -
 -static inline
 -int64_t self_announce_delay(int round)
 -{
 -    assert(round < SELF_ANNOUNCE_ROUNDS && round > 0);
 -    /* delay 50ms, 150ms, 250ms, ... */
 -    return 50 + (SELF_ANNOUNCE_ROUNDS - round - 1) * 100;
 -}
 -
  AnnounceParameters *migrate_announce_params(void);
  /* migration/savevm.c */
 diff --git a/include/net/announce.h b/include/net/announce.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/net/announce.h
 +++ b/include/net/announce.h
@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_reset(AnnounceTimer *timer,
                                 QEMUTimerCB *cb,
                                 void *opaque);
 +void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params);
 +
  #endif
 diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/sysemu.h
 +++ b/include/sysemu/sysemu.h
@@ -XXX,XX +XXX,XX @@ extern bool machine_init_done;
  void qemu_add_machine_init_done_notifier(Notifier *notify);
  void qemu_remove_machine_init_done_notifier(Notifier *notify);
 -void qemu_announce_self(void);
 -
  extern int autostart;
  typedef enum {
 diff --git a/migration/migration.c b/migration/migration.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/migration.c
 +++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@ static void process_incoming_migration_bh(void *opaque)
       * This must happen after all error conditions are dealt with and
       * we're sure the VM is going to be running on this host.
       */
 -    qemu_announce_self();
 +    qemu_announce_self(&mis->announce_timer, migrate_announce_params());
      if (multifd_load_cleanup(&local_err) != 0) {
          error_report_err(local_err);
 diff --git a/migration/migration.h b/migration/migration.h
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/migration.h
 +++ b/migration/migration.h
@@ -XXX,XX +XXX,XX @@
  #include "qemu/coroutine_int.h"
  #include "hw/qdev.h"
  #include "io/channel.h"
 +#include "net/announce.h"
  struct PostcopyBlocktimeContext;
@@ -XXX,XX +XXX,XX @@ struct MigrationIncomingState {
       */
      QemuEvent main_thread_load_event;
 +    /* For network announces */
 +    AnnounceTimer  announce_timer;
 +
      size_t         largest_page_size;
      bool           have_fault_thread;
      QemuThread     fault_thread;
 diff --git a/migration/savevm.c b/migration/savevm.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/savevm.c
 +++ b/migration/savevm.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/replay.h"
  #include "qjson.h"
  #include "migration/colo.h"
 -
 -#ifndef ETH_P_RARP
 -#define ETH_P_RARP 0x8035
 -#endif
 -#define ARP_HTYPE_ETH 0x0001
 -#define ARP_PTYPE_IP 0x0800
 -#define ARP_OP_REQUEST_REV 0x3
 +#include "net/announce.h"
  const unsigned int postcopy_ram_discard_version = 0;
@@ -XXX,XX +XXX,XX @@ static struct mig_cmd_args {
   * generic extendable format with an exception for two old entities.
   */
 -static int announce_self_create(uint8_t *buf,
 -                                uint8_t *mac_addr)
 -{
 -    /* Ethernet header. */
 -    memset(buf, 0xff, 6);         /* destination MAC addr */
 -    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
 -    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
 -
 -    /* RARP header. */
 -    *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
 -    *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
 -    *(buf + 18) = 6; /* hardware addr length (ethernet) */
 -    *(buf + 19) = 4; /* protocol addr length (IPv4) */
 -    *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
 -    memcpy(buf + 22, mac_addr, 6); /* source hw addr */
 -    memset(buf + 28, 0x00, 4);     /* source protocol addr */
 -    memcpy(buf + 32, mac_addr, 6); /* target hw addr */
 -    memset(buf + 38, 0x00, 4);     /* target protocol addr */
 -
 -    /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
 -    memset(buf + 42, 0x00, 18);
 -
 -    return 60; /* len (FCS will be added by hardware) */
 -}
 -
 -static void qemu_announce_self_iter(NICState *nic, void *opaque)
 -{
 -    uint8_t buf[60];
 -    int len;
 -
 -    trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
 -    len = announce_self_create(buf, nic->conf->macaddr.a);
 -
 -    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
 -}
 -
 -
 -static void qemu_announce_self_once(void *opaque)
 -{
 -    static int count = SELF_ANNOUNCE_ROUNDS;
 -    QEMUTimer *timer = *(QEMUTimer **)opaque;
 -
 -    qemu_foreach_nic(qemu_announce_self_iter, NULL);
 -
 -    if (--count) {
 -        /* delay 50ms, 150ms, 250ms, ... */
 -        timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
 -                  self_announce_delay(count));
 -    } else {
 -            timer_del(timer);
 -            timer_free(timer);
 -    }
 -}
 -
 -void qemu_announce_self(void)
 -{
 -    static QEMUTimer *timer;
 -    timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
 -    qemu_announce_self_once(&timer);
 -}
 -
  /***********************************************************/
  /* savevm/loadvm support */
@@ -XXX,XX +XXX,XX @@ static void loadvm_postcopy_handle_run_bh(void *opaque)
  {
      Error *local_err = NULL;
      HandleRunBhData *data = opaque;
 +    MigrationIncomingState *mis = migration_incoming_get_current();
      /* TODO we should move all of this lot into postcopy_ram.c or a shared code
       * in migration.c
       */
      cpu_synchronize_all_post_init();
 -    qemu_announce_self();
 +    qemu_announce_self(&mis->announce_timer, migrate_announce_params());
      /* Make sure all file formats flush their mutable metadata.
       * If we get an error here, just don't restart the VM yet. */
 diff --git a/migration/trace-events b/migration/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/trace-events
 +++ b/migration/trace-events
@@ -XXX,XX +XXX,XX @@ vmstate_save_state_top(const char *idstr) "%s"
  vmstate_subsection_save_loop(const char *name, const char *sub) "%s/%s"
  vmstate_subsection_save_top(const char *idstr) "%s"
  vmstate_load(const char *idstr, const char *vmsd_name) "%s, %s"
 -qemu_announce_self_iter(const char *mac) "%s"
  # migration/vmstate.c
  vmstate_load_field_error(const char *field, int ret) "field \"%s\" load failed, ret = %d"
 diff --git a/net/announce.c b/net/announce.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/announce.c
 +++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qemu-common.h"
  #include "net/announce.h"
 +#include "net/net.h"
  #include "qapi/clone-visitor.h"
  #include "qapi/qapi-visit-net.h"
 +#include "trace.h"
  int64_t qemu_announce_timer_step(AnnounceTimer *timer)
  {
@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_reset(AnnounceTimer *timer,
      timer->type = type;
      timer->tm = timer_new_ms(type, cb, opaque);
  }
 +
 +#ifndef ETH_P_RARP
 +#define ETH_P_RARP 0x8035
 +#endif
 +#define ARP_HTYPE_ETH 0x0001
 +#define ARP_PTYPE_IP 0x0800
 +#define ARP_OP_REQUEST_REV 0x3
 +
 +static int announce_self_create(uint8_t *buf,
 +                                uint8_t *mac_addr)
 +{
 +    /* Ethernet header. */
 +    memset(buf, 0xff, 6);         /* destination MAC addr */
 +    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
 +    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
 +
 +    /* RARP header. */
 +    *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
 +    *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
 +    *(buf + 18) = 6; /* hardware addr length (ethernet) */
 +    *(buf + 19) = 4; /* protocol addr length (IPv4) */
 +    *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
 +    memcpy(buf + 22, mac_addr, 6); /* source hw addr */
 +    memset(buf + 28, 0x00, 4);     /* source protocol addr */
 +    memcpy(buf + 32, mac_addr, 6); /* target hw addr */
 +    memset(buf + 38, 0x00, 4);     /* target protocol addr */
 +
 +    /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
 +    memset(buf + 42, 0x00, 18);
 +
 +    return 60; /* len (FCS will be added by hardware) */
 +}
 +
 +static void qemu_announce_self_iter(NICState *nic, void *opaque)
 +{
 +    uint8_t buf[60];
 +    int len;
 +
 +    trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
 +    len = announce_self_create(buf, nic->conf->macaddr.a);
 +
 +    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
 +}
 +static void qemu_announce_self_once(void *opaque)
 +{
 +    AnnounceTimer *timer = (AnnounceTimer *)opaque;
 +
 +    qemu_foreach_nic(qemu_announce_self_iter, NULL);
 +
 +    if (--timer->round) {
 +        qemu_announce_timer_step(timer);
 +    } else {
 +        qemu_announce_timer_del(timer);
 +    }
 +}
 +
 +void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
 +{
 +    qemu_announce_timer_reset(timer, params, QEMU_CLOCK_REALTIME,
 +                              qemu_announce_self_once, timer);
 +    if (params->rounds) {
 +        qemu_announce_self_once(timer);
 +    } else {
 +        qemu_announce_timer_del(timer);
 +    }
 +}
 diff --git a/net/trace-events b/net/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/net/trace-events
 +++ b/net/trace-events
@@ -XXX,XX +XXX,XX @@
  # See docs/devel/tracing.txt for syntax documentation.
 +# net/announce.c
 +qemu_announce_self_iter(const char *mac) "%s"
 +
  # net/vhost-user.c
  vhost_user_event(const char *chr, int event) "chr: %s got event: %d"
 --
 .5.0

-New patch
+[Qemu-devel] [PULL V2 09/13] net: Add a network device specific self-announcement ability
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
+Some network devices have a capability to do self announcements
+(ex: virtio-net).  Add infrastructure that would allow devices
+to expose this ability.
+Signed-off-by: Vladislav Yasevich <vyasevic@redhat.com>
+Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/net/net.h | 2 ++
+ net/announce.c    | 5 +++++
+files changed, 7 insertions(+)
+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 int (SetVnetLE)(NetClientState *, bool);
+ typedef int (SetVnetBE)(NetClientState *, bool);
+ typedef struct SocketReadState SocketReadState;
+ typedef void (SocketReadStateFinalize)(SocketReadState *rs);
++typedef void (NetAnnounce)(NetClientState *);
+ typedef struct NetClientInfo {
+     NetClientDriver type;
+@@ -XXX,XX +XXX,XX @@ typedef struct NetClientInfo {
+     SetVnetHdrLen *set_vnet_hdr_len;
+     SetVnetLE *set_vnet_le;
+     SetVnetBE *set_vnet_be;
++    NetAnnounce *announce;
+ } NetClientInfo;
+ struct NetClientState {
+diff --git a/net/announce.c b/net/announce.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/announce.c
++++ b/net/announce.c
+@@ -XXX,XX +XXX,XX @@ static void qemu_announce_self_iter(NICState *nic, void *opaque)
+     len = announce_self_create(buf, nic->conf->macaddr.a);
+     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
++
++    /* if the NIC provides it's own announcement support, use it as well */
++    if (nic->ncs->info->announce) {
++        nic->ncs->info->announce(nic->ncs);
++    }
+ }
+ static void qemu_announce_self_once(void *opaque)
+ {
+--
+.5.0

-[Qemu-devel] [PULL 2/4] e1000: Delay flush queue when receive RCTL
+[Qemu-devel] [PULL V2 10/13] virtio-net: Allow qemu_announce_self to trigger virtio announcements
-From: yuchenlin <yuchenlin@synology.com>
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
-Due to too early RCT0 interrput, win10x32 may hang on booting.
+Expose the virtio-net self announcement capability and allow
-This problem can be reproduced by doing power cycle on win10x32 guest.
+qemu_announce_self() to call it.
 In our environment, we have 10 win10x32 and stress power cycle.
 The problem will happen about 20 rounds.
-Below shows some log with comment:
+These announces are caused by something external (i.e. the
 announce-self command); they won't trigger if the migration
 counter is triggering announces at the same time.
-The normal case:
+Signed-off-by: Vladislav Yasevich <vyasevic@redhat.com>
+Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
-@1551928392.984687:e1000x_rx_disabled Received packet dropped
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 because receive is disabled RCTL = 0
 @1551928392.985655:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 @1551928392.985801:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551928393.056710:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: ICR read: 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551928393.077548:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: ICR read: 0
 e1000: set_ics 2, ICR 0, IMR 0
 e1000: set_ics 2, ICR 2, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551928393.102974:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 @1551928393.103267:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: RCTL: 255, mac_reg[RCTL] = 0x40002 <- win10x32 says it can handle
 RX now
 e1000: set_ics 0, ICR 2, IMR 9d <- unmask interrupt
 e1000: RCTL: 255, mac_reg[RCTL] = 0x48002
 e1000: set_ics 80, ICR 2, IMR 9d <- interrupt and work!
 ...
 The bad case:
 @1551930483.117766:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 @1551930483.118398:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551930483.198063:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: ICR read: 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551930483.218675:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: set_ics 0, ICR 0, IMR 0
 e1000: ICR read: 0
 e1000: set_ics 2, ICR 0, IMR 0
 e1000: set_ics 2, ICR 2, IMR 0
 e1000: RCTL: 0, mac_reg[RCTL] = 0x0
 @1551930483.241768:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 @1551930483.241979:e1000x_rx_disabled Received packet dropped
 because receive is disabled RCTL = 0
 e1000: RCTL: 255, mac_reg[RCTL] = 0x40002 <- win10x32 says it can handle
 RX now
 e1000: set_ics 80, ICR 2, IMR 0 <- flush queue (caused by setting RCTL)
 e1000: set_ics 0, ICR 82, IMR 9d <- unmask interrupt and because 0x82&0x9d
 != 0 generate interrupt, hang on here...
 To workaround this problem, simply delay flush queue. Also stop receiving
 when timer is going to run.
 Tested on CentOS, Win7SP1x64 and Win10x32.
 Signed-off-by: yuchenlin <yuchenlin@synology.com>
 Reviewed-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/e1000.c | 24 ++++++++++++++++++++++--
+ hw/net/trace-events |  1 +
-file changed, 22 insertions(+), 2 deletions(-)
+ hw/net/virtio-net.c | 35 ++++++++++++++++++++++++++++++++---
 files changed, 33 insertions(+), 3 deletions(-)
-diff --git a/hw/net/e1000.c b/hw/net/e1000.c
+diff --git a/hw/net/trace-events b/hw/net/trace-events
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/e1000.c
+--- a/hw/net/trace-events
-+++ b/hw/net/e1000.c
++++ b/hw/net/trace-events
-@@ -XXX,XX +XXX,XX @@ typedef struct E1000State_st {
+@@ -XXX,XX +XXX,XX @@ sunhme_rx_desc(uint32_t addr, int offset, uint32_t status, int len, int cr, int
-     bool mit_irq_level;        /* Tracks interrupt pin level. */
+ sunhme_rx_xsum_calc(uint16_t xsum) "calculated incoming xsum as 0x%x"
-     uint32_t mit_ide;          /* Tracks E1000_TXD_CMD_IDE bit. */
+ # hw/net/virtio-net.c
-+    QEMUTimer *flush_queue_timer;
++virtio_net_announce_notify(void) ""
  virtio_net_announce_timer(int round) "%d"
  virtio_net_handle_announce(int round) "%d"
  virtio_net_post_load_device(void)
 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 bool virtio_net_started(VirtIONet *n, uint8_t status)
          (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
  }
 +static void virtio_net_announce_notify(VirtIONet *net)
 +{
 +    VirtIODevice *vdev = VIRTIO_DEVICE(net);
 +    trace_virtio_net_announce_notify();
 +
- /* Compatibility flags for migration to/from qemu 1.3.0 and older */
++    net->status |= VIRTIO_NET_S_ANNOUNCE;
- #define E1000_FLAG_AUTONEG_BIT 0
++    virtio_notify_config(vdev);
  #define E1000_FLAG_MIT_BIT 1
@@ -XXX,XX +XXX,XX @@ static void e1000_reset(void *opaque)
      timer_del(d->autoneg_timer);
      timer_del(d->mit_timer);
 +    timer_del(d->flush_queue_timer);
      d->mit_timer_on = 0;
      d->mit_irq_level = 0;
      d->mit_ide = 0;
@@ -XXX,XX +XXX,XX @@ set_ctrl(E1000State *s, int index, uint32_t val)
  }
  static void
 +e1000_flush_queue_timer(void *opaque)
 +{
 +    E1000State *s = opaque;
 +
 +    qemu_flush_queued_packets(qemu_get_queue(s->nic));
 +}
 +
-+static void
+ static void virtio_net_announce_timer(void *opaque)
  set_rx_control(E1000State *s, int index, uint32_t val)
  {
-     s->mac_reg[RCTL] = val;
+     VirtIONet *n = opaque;
-@@ -XXX,XX +XXX,XX @@ set_rx_control(E1000State *s, int index, uint32_t val)
+-    VirtIODevice *vdev = VIRTIO_DEVICE(n);
-     s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1;
+     trace_virtio_net_announce_timer(n->announce_timer.round);
-     DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT],
-            s->mac_reg[RCTL]);
+     n->announce_timer.round--;
--    qemu_flush_queued_packets(qemu_get_queue(s->nic));
+-    n->status |= VIRTIO_NET_S_ANNOUNCE;
-+    timer_mod(s->flush_queue_timer,
+-    virtio_notify_config(vdev);
-+              qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 1000);
++    virtio_net_announce_notify(n);
- }
++}
++
- static void
++static void virtio_net_announce(NetClientState *nc)
-@@ -XXX,XX +XXX,XX @@ e1000_can_receive(NetClientState *nc)
++{
-     E1000State *s = qemu_get_nic_opaque(nc);
++    VirtIONet *n = qemu_get_nic_opaque(nc);
++    VirtIODevice *vdev = VIRTIO_DEVICE(n);
-     return e1000x_rx_ready(&s->parent_obj, s->mac_reg) &&
++
--        e1000_has_rxbufs(s, 1);
++    /*
-+        e1000_has_rxbufs(s, 1) && !timer_pending(s->flush_queue_timer);
++     * Make sure the virtio migration announcement timer isn't running
- }
++     * If it is, let it trigger announcement so that we do not cause
++     * confusion.
- static uint64_t rx_desc_base(E1000State *s)
++     */
-@@ -XXX,XX +XXX,XX @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt)
++    if (n->announce_timer.round) {
-         return -1;
++        return;
      }
 +    if (timer_pending(s->flush_queue_timer)) {
 +        return 0;
 +    }
 +
-     /* Pad to minimum Ethernet frame length */
++    if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
-     if (size < sizeof(min_buf)) {
++        virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
-         iov_to_buf(iov, iovcnt, 0, min_buf, size);
++            virtio_net_announce_notify(n);
-@@ -XXX,XX +XXX,XX @@ pci_e1000_uninit(PCIDevice *dev)
++    }
      timer_free(d->autoneg_timer);
      timer_del(d->mit_timer);
      timer_free(d->mit_timer);
 +    timer_del(d->flush_queue_timer);
 +    timer_free(d->flush_queue_timer);
      qemu_del_nic(d->nic);
  }
-@@ -XXX,XX +XXX,XX @@ static void pci_e1000_realize(PCIDevice *pci_dev, Error **errp)
+ static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
+@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_virtio_info = {
-     d->autoneg_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, e1000_autoneg_timer, d);
+     .receive = virtio_net_receive,
-     d->mit_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, e1000_mit_timer, d);
+     .link_status_changed = virtio_net_set_link_status,
-+    d->flush_queue_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
+     .query_rx_filter = virtio_net_query_rxfilter,
-+                                        e1000_flush_queue_timer, d);
++    .announce = virtio_net_announce,
- }
+ };
- static void qdev_e1000_reset(DeviceState *dev)
+ static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
      qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
                                QEMU_CLOCK_VIRTUAL,
                                virtio_net_announce_timer, n);
 +    n->announce_timer.round = 0;
      if (n->netclient_type) {
          /*
 --
 .5.0

-New patch
+[Qemu-devel] [PULL V2 11/13] qmp: Add announce-self command
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
+Add a qmp command that can trigger guest announcements.
+It uses its own announce-timer instance, and parameters
+passed to it explicitly in the command.
+Like most qmp commands, it's in the main thread/bql, so
+there's no racing with any outstanding timer.
+Based on work of Germano Veit Michel <germano@redhat.com> and
+                 Vladislav Yasevich <vyasevic@redhat.com>
+Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/announce.c |  7 +++++++
+ qapi/net.json  | 20 ++++++++++++++++++++
+files changed, 27 insertions(+)
+diff --git a/net/announce.c b/net/announce.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/announce.c
++++ b/net/announce.c
+@@ -XXX,XX +XXX,XX @@
+ #include "net/net.h"
+ #include "qapi/clone-visitor.h"
+ #include "qapi/qapi-visit-net.h"
++#include "qapi/qapi-commands-net.h"
+ #include "trace.h"
+ int64_t qemu_announce_timer_step(AnnounceTimer *timer)
+@@ -XXX,XX +XXX,XX @@ void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
+         qemu_announce_timer_del(timer);
+     }
+ }
++
++void qmp_announce_self(AnnounceParameters *params, Error **errp)
++{
++    static AnnounceTimer announce_timer;
++    qemu_announce_self(&announce_timer, params);
++}
+diff --git a/qapi/net.json b/qapi/net.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/net.json
++++ b/qapi/net.json
+@@ -XXX,XX +XXX,XX @@
+             'max': 'int',
+             'rounds': 'int',
+             'step': 'int' } }
++
++##
++# @announce-self:
++#
++# Trigger generation of broadcast RARP frames to update network switches.
++# This can be useful when network bonds fail-over the active slave.
++#
++# @params: AnnounceParameters giving timing and repetition count of announce
++#
++# Example:
++#
++# -> { "execute": "announce-self"
++#      "arguments": {
++#          "initial": 50, "max": 550, "rounds": 10, "step": 50 } }
++# <- { "return": {} }
++#
++# Since: 4.0
++##
++{ 'command': 'announce-self', 'boxed': true,
++  'data' : 'AnnounceParameters'}
+--
+.5.0

-New patch
+[Qemu-devel] [PULL V2 12/13] hmp: Add hmp_announce_self
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
+Add an HMP command to trigger self annocements.
+Unlike the QMP command (which takes a set of parameters), the HMP
+command reuses the set of parameters used for migration.
+Signend-off-by: Vladislav Yasevich <vyasevic@redhat.com>
+Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hmp-commands.hx  | 16 ++++++++++++++++
+ hmp.c            |  5 +++++
+ hmp.h            |  1 +
+ tests/test-hmp.c |  1 +
+files changed, 23 insertions(+)
+diff --git a/hmp-commands.hx b/hmp-commands.hx
+index XXXXXXX..XXXXXXX 100644
+--- a/hmp-commands.hx
++++ b/hmp-commands.hx
+@@ -XXX,XX +XXX,XX @@ stops because the size limit is reached.
+ ETEXI
+     {
++        .name       = "announce_self",
++        .args_type  = "",
++        .params     = "",
++        .help       = "Trigger GARP/RARP announcements",
++        .cmd        = hmp_announce_self,
++    },
++
++STEXI
++@item announce_self
++@findex announce_self
++Trigger a round of GARP/RARP broadcasts; this is useful for explicitly updating the
++network infrastructure after a reconfiguration or some forms of migration.
++The timings of the round are set by the migration announce parameters.
++ETEXI
++
++    {
+         .name       = "migrate",
+         .args_type  = "detach:-d,blk:-b,inc:-i,resume:-r,uri:s",
+         .params     = "[-d] [-b] [-i] [-r] uri",
+diff --git a/hmp.c b/hmp.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hmp.c
++++ b/hmp.c
+@@ -XXX,XX +XXX,XX @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
+ }
++void hmp_announce_self(Monitor *mon, const QDict *qdict)
++{
++    qmp_announce_self(migrate_announce_params(), NULL);
++}
++
+ void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
+ {
+     qmp_migrate_cancel(NULL);
+diff --git a/hmp.h b/hmp.h
+index XXXXXXX..XXXXXXX 100644
+--- a/hmp.h
++++ b/hmp.h
+@@ -XXX,XX +XXX,XX @@ void hmp_sync_profile(Monitor *mon, const QDict *qdict);
+ void hmp_system_reset(Monitor *mon, const QDict *qdict);
+ void hmp_system_powerdown(Monitor *mon, const QDict *qdict);
+ void hmp_exit_preconfig(Monitor *mon, const QDict *qdict);
++void hmp_announce_self(Monitor *mon, const QDict *qdict);
+ void hmp_cpu(Monitor *mon, const QDict *qdict);
+ void hmp_memsave(Monitor *mon, const QDict *qdict);
+ void hmp_pmemsave(Monitor *mon, const QDict *qdict);
+diff --git a/tests/test-hmp.c b/tests/test-hmp.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/test-hmp.c
++++ b/tests/test-hmp.c
+@@ -XXX,XX +XXX,XX @@
+ static int verbose;
+ static const char *hmp_cmds[] = {
++    "announce_self",
+     "boot_set ndc",
+     "chardev-add null,id=testchardev1",
+     "chardev-send-break testchardev1",
+--
+.5.0

-[Qemu-devel] [PULL 1/4] net/socket: learn to talk with a unix dgram socket
+[Qemu-devel] [PULL V2 13/13] tests: Add a test for qemu self announcements
-From: Marc-André Lureau <marcandre.lureau@redhat.com>
+From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
--net socket has a fd argument, and may be passed pre-opened sockets.
+We now expose qemu_announce_self through QMP and HMP.  Add a test
 with some very basic packet validation (make sure we get a RARP).
-TCP sockets use framing.
+Signed-off-by: Vlad Yasevich <vyasevic@redhat.com>
-UDP sockets have datagram boundaries.
+Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 When given a unix dgram socket, it will be able to read from it, but
 will attempt to send on the dgram_dst, which is unset. The other end
 will not receive the data.
 Let's teach -net socket to recognize a UNIX DGRAM socket, and use the
 regular send() command (without dgram_dst).
 This makes running slirp out-of-process possible that
 way (python pseudo-code):
 a, b = socket.socketpair(socket.AF_UNIX, socket.SOCK_DGRAM)
 subprocess.Popen('qemu -net socket,fd=%d -net user' % a.fileno(), shell=True)
 subprocess.Popen('qemu ... -net nic -net socket,fd=%d' % b.fileno(), shell=True)
 Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/socket.c | 25 +++++++++++++++++++++----
+ tests/Makefile.include     |  3 ++
-file changed, 21 insertions(+), 4 deletions(-)
+ tests/test-announce-self.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++
 files changed, 85 insertions(+)
  create mode 100644 tests/test-announce-self.c
-diff --git a/net/socket.c b/net/socket.c
+diff --git a/tests/Makefile.include b/tests/Makefile.include
 index XXXXXXX..XXXXXXX 100644
---- a/net/socket.c
+--- a/tests/Makefile.include
-+++ b/net/socket.c
++++ b/tests/Makefile.include
-@@ -XXX,XX +XXX,XX @@ static ssize_t net_socket_receive_dgram(NetClientState *nc, const uint8_t *buf,
+@@ -XXX,XX +XXX,XX @@ check-qtest-i386-$(CONFIG_SLIRP) += tests/test-netfilter$(EXESUF)
-     ssize_t ret;
+ check-qtest-i386-$(CONFIG_POSIX) += tests/test-filter-mirror$(EXESUF)
+ check-qtest-i386-$(CONFIG_RTL8139_PCI) += tests/test-filter-redirector$(EXESUF)
-     do {
+ check-qtest-i386-y += tests/migration-test$(EXESUF)
--        ret = qemu_sendto(s->fd, buf, size, 0,
++check-qtest-i386-y += tests/test-announce-self$(EXESUF)
--                          (struct sockaddr *)&s->dgram_dst,
+ check-qtest-i386-y += tests/test-x86-cpuid-compat$(EXESUF)
--                          sizeof(s->dgram_dst));
+ check-qtest-i386-y += tests/numa-test$(EXESUF)
-+        if (s->dgram_dst.sin_family != AF_UNIX) {
+ check-qtest-x86_64-y += $(check-qtest-i386-y)
-+            ret = qemu_sendto(s->fd, buf, size, 0,
+@@ -XXX,XX +XXX,XX @@ check-qtest-ppc64-$(CONFIG_PSERIES) += tests/spapr-phb-test$(EXESUF)
-+                              (struct sockaddr *)&s->dgram_dst,
+ check-qtest-ppc64-$(CONFIG_PSERIES) += tests/device-plug-test$(EXESUF)
-+                              sizeof(s->dgram_dst));
+ check-qtest-ppc64-$(CONFIG_POWERNV) += tests/pnv-xscom-test$(EXESUF)
-+        } else {
+ check-qtest-ppc64-y += tests/migration-test$(EXESUF)
-+            ret = send(s->fd, buf, size, 0);
++check-qtest-ppc64-y += tests/test-announce-self$(EXESUF)
-+        }
+ check-qtest-ppc64-$(CONFIG_PSERIES) += tests/rtas-test$(EXESUF)
-     } while (ret == -1 && errno == EINTR);
+ check-qtest-ppc64-$(CONFIG_SLIRP) += tests/pxe-test$(EXESUF)
+ check-qtest-ppc64-$(CONFIG_USB_OHCI) += tests/usb-hcd-ohci-test$(EXESUF)
-     if (ret == -1 && errno == EAGAIN) {
+@@ -XXX,XX +XXX,XX @@ tests/usb-hcd-ehci-test$(EXESUF): tests/usb-hcd-ehci-test.o $(libqos-usb-obj-y)
-@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
+ tests/usb-hcd-xhci-test$(EXESUF): tests/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
-     int newfd;
+ tests/cpu-plug-test$(EXESUF): tests/cpu-plug-test.o
-     NetClientState *nc;
+ tests/migration-test$(EXESUF): tests/migration-test.o
-     NetSocketState *s;
++tests/test-announce-self$(EXESUF): tests/test-announce-self.o
-+    SocketAddress *sa;
+ tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o $(test-util-obj-y) \
-+    SocketAddressType sa_type;
+     $(qtest-obj-y) $(test-io-obj-y) $(libqos-virtio-obj-y) $(libqos-pc-obj-y) \
      $(chardev-obj-y)
 diff --git a/tests/test-announce-self.c b/tests/test-announce-self.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/test-announce-self.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QTest testcase for qemu_announce_self
 + *
 + * Copyright (c) 2017 Red hat, Inc.
 + * Copyright (c) 2014 SUSE LINUX Products GmbH
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
-+    sa = socket_local_address(fd, errp);
++#include "qemu/osdep.h"
-+    if (!sa) {
++#include "libqtest.h"
-+        return NULL;
++#include "qapi/qmp/qdict.h"
-+    }
++#include "qemu-common.h"
-+    sa_type = sa->type;
++#include "qemu/sockets.h"
-+    qapi_free_SocketAddress(sa);
++#include "qemu/iov.h"
++#include "libqos/libqos-pc.h"
-     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
++#include "libqos/libqos-spapr.h"
       * Because this may be "shared" socket from a "master" process, datagrams would be recv()
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
                   "socket: fd=%d (cloned mcast=%s:%d)",
                   fd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
      } else {
 +        if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
 +            s->dgram_dst.sin_family = AF_UNIX;
 +        }
 +
-         snprintf(nc->info_str, sizeof(nc->info_str),
++#ifndef ETH_P_RARP
--                 "socket: fd=%d", fd);
++#define ETH_P_RARP 0x8035
-+                 "socket: fd=%d %s", fd, SocketAddressType_str(sa_type));
++#endif
-     }
++
++static QTestState *test_init(int socket)
-     return s;
++{
 +    char *args;
 +
 +    args = g_strdup_printf("-netdev socket,fd=%d,id=hs0 -device "
 +                           "virtio-net-pci,netdev=hs0", socket);
 +
 +    return qtest_start(args);
 +}
 +
 +
 +static void test_announce(int socket)
 +{
 +    char buffer[60];
 +    int len;
 +    QDict *rsp;
 +    int ret;
 +    uint16_t *proto = (uint16_t *)&buffer[12];
 +
 +    rsp = qmp("{ 'execute' : 'announce-self', "
 +                  " 'arguments': {"
 +                      " 'initial': 50, 'max': 550,"
 +                      " 'rounds': 10, 'step': 50 } }");
 +    assert(!qdict_haskey(rsp, "error"));
 +    qobject_unref(rsp);
 +
 +    /* Catch the packet and make sure it's a RARP */
 +    ret = qemu_recv(socket, &len, sizeof(len), 0);
 +    g_assert_cmpint(ret, ==,  sizeof(len));
 +    len = ntohl(len);
 +
 +    ret = qemu_recv(socket, buffer, len, 0);
 +    g_assert_cmpint(*proto, ==, htons(ETH_P_RARP));
 +}
 +
 +static void setup(gconstpointer data)
 +{
 +    QTestState *qs;
 +    void (*func) (int socket) = data;
 +    int sv[2], ret;
 +
 +    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sv);
 +    g_assert_cmpint(ret, !=, -1);
 +
 +    qs = test_init(sv[1]);
 +    func(sv[0]);
 +
 +    /* End test */
 +    close(sv[0]);
 +    qtest_quit(qs);
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    g_test_init(&argc, &argv, NULL);
 +    qtest_add_data_func("/virtio/net/test_announce_self", test_announce, setup);
 +
 +    return g_test_run();
 +}
 --
 .5.0

The following changes since commit a04d91c701251a9b32b7364ddb48029ba024cb75:

Merge remote-tracking branch 'remotes/alistair/tags/pull-device-tree-20190327' into staging (2019-03-28 12:39:43 +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 ab79237a15e8f8c23310291b672d83374cf17935:

net: tap: use qemu_set_nonblock (2019-03-29 15:22:18 +0800)

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

----------------------------------------------------------------
Li Qiang (1):
      net: tap: use qemu_set_nonblock

Marc-André Lureau (1):
      net/socket: learn to talk with a unix dgram socket

Zhang Chen (1):
      MAINTAINERS: Update the latest email address

yuchenlin (1):
      e1000: Delay flush queue when receive RCTL

MAINTAINERS    |  2 +-
 hw/net/e1000.c | 24 ++++++++++++++++++++++--
 net/socket.c   | 25 +++++++++++++++++++++----
 net/tap.c      | 10 +++++-----
 4 files changed, 49 insertions(+), 12 deletions(-)

From: Marc-André Lureau <marcandre.lureau@redhat.com>

-net socket has a fd argument, and may be passed pre-opened sockets.

TCP sockets use framing.
UDP sockets have datagram boundaries.

When given a unix dgram socket, it will be able to read from it, but
will attempt to send on the dgram_dst, which is unset. The other end
will not receive the data.

Let's teach -net socket to recognize a UNIX DGRAM socket, and use the
regular send() command (without dgram_dst).

This makes running slirp out-of-process possible that
way (python pseudo-code):

a, b = socket.socketpair(socket.AF_UNIX, socket.SOCK_DGRAM)

subprocess.Popen('qemu -net socket,fd=%d -net user' % a.fileno(), shell=True)
subprocess.Popen('qemu ... -net nic -net socket,fd=%d' % b.fileno(), shell=True)

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/socket.c | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

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 ssize_t net_socket_receive_dgram(NetClientState *nc, const uint8_t *buf,
     ssize_t ret;
 
     do {
-        ret = qemu_sendto(s->fd, buf, size, 0,
-                          (struct sockaddr *)&s->dgram_dst,
-                          sizeof(s->dgram_dst));
+        if (s->dgram_dst.sin_family != AF_UNIX) {
+            ret = qemu_sendto(s->fd, buf, size, 0,
+                              (struct sockaddr *)&s->dgram_dst,
+                              sizeof(s->dgram_dst));
+        } else {
+            ret = send(s->fd, buf, size, 0);
+        }
     } while (ret == -1 && errno == EINTR);
 
     if (ret == -1 && errno == EAGAIN) {
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
     int newfd;
     NetClientState *nc;
     NetSocketState *s;
+    SocketAddress *sa;
+    SocketAddressType sa_type;
+
+    sa = socket_local_address(fd, errp);
+    if (!sa) {
+        return NULL;
+    }
+    sa_type = sa->type;
+    qapi_free_SocketAddress(sa);
 
     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
                  "socket: fd=%d (cloned mcast=%s:%d)",
                  fd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
     } else {
+        if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
+            s->dgram_dst.sin_family = AF_UNIX;
+        }
+
         snprintf(nc->info_str, sizeof(nc->info_str),
-                 "socket: fd=%d", fd);
+                 "socket: fd=%d %s", fd, SocketAddressType_str(sa_type));
     }
 
     return s;
-- 
2.5.0

From: yuchenlin <yuchenlin@synology.com>

Due to too early RCT0 interrput, win10x32 may hang on booting.
This problem can be reproduced by doing power cycle on win10x32 guest.
In our environment, we have 10 win10x32 and stress power cycle.
The problem will happen about 20 rounds.

Below shows some log with comment:

The normal case:

22831@1551928392.984687:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
22831@1551928392.985655:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
22831@1551928392.985801:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
22831@1551928393.056710:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: ICR read: 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
22831@1551928393.077548:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: ICR read: 0
e1000: set_ics 2, ICR 0, IMR 0
e1000: set_ics 2, ICR 2, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
22831@1551928393.102974:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
22831@1551928393.103267:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: RCTL: 255, mac_reg[RCTL] = 0x40002 <- win10x32 says it can handle
RX now
e1000: set_ics 0, ICR 2, IMR 9d <- unmask interrupt
e1000: RCTL: 255, mac_reg[RCTL] = 0x48002
e1000: set_ics 80, ICR 2, IMR 9d <- interrupt and work!
...

The bad case:

27744@1551930483.117766:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
27744@1551930483.118398:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
27744@1551930483.198063:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: ICR read: 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
27744@1551930483.218675:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: set_ics 0, ICR 0, IMR 0
e1000: ICR read: 0
e1000: set_ics 2, ICR 0, IMR 0
e1000: set_ics 2, ICR 2, IMR 0
e1000: RCTL: 0, mac_reg[RCTL] = 0x0
27744@1551930483.241768:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
27744@1551930483.241979:e1000x_rx_disabled Received packet dropped
because receive is disabled RCTL = 0
e1000: RCTL: 255, mac_reg[RCTL] = 0x40002 <- win10x32 says it can handle
RX now
e1000: set_ics 80, ICR 2, IMR 0 <- flush queue (caused by setting RCTL)
e1000: set_ics 0, ICR 82, IMR 9d <- unmask interrupt and because 0x82&0x9d
!= 0 generate interrupt, hang on here...

To workaround this problem, simply delay flush queue. Also stop receiving
when timer is going to run.

Tested on CentOS, Win7SP1x64 and Win10x32.

Signed-off-by: yuchenlin <yuchenlin@synology.com>
Reviewed-by: Dmitry Fleytman <dmitry.fleytman@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000.c | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/hw/net/e1000.c b/hw/net/e1000.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000.c
+++ b/hw/net/e1000.c
@@ -XXX,XX +XXX,XX @@ typedef struct E1000State_st {
     bool mit_irq_level;        /* Tracks interrupt pin level. */
     uint32_t mit_ide;          /* Tracks E1000_TXD_CMD_IDE bit. */
 
+    QEMUTimer *flush_queue_timer;
+
 /* Compatibility flags for migration to/from qemu 1.3.0 and older */
 #define E1000_FLAG_AUTONEG_BIT 0
 #define E1000_FLAG_MIT_BIT 1
@@ -XXX,XX +XXX,XX @@ static void e1000_reset(void *opaque)
 
     timer_del(d->autoneg_timer);
     timer_del(d->mit_timer);
+    timer_del(d->flush_queue_timer);
     d->mit_timer_on = 0;
     d->mit_irq_level = 0;
     d->mit_ide = 0;
@@ -XXX,XX +XXX,XX @@ set_ctrl(E1000State *s, int index, uint32_t val)
 }
 
 static void
+e1000_flush_queue_timer(void *opaque)
+{
+    E1000State *s = opaque;
+
+    qemu_flush_queued_packets(qemu_get_queue(s->nic));
+}
+
+static void
 set_rx_control(E1000State *s, int index, uint32_t val)
 {
     s->mac_reg[RCTL] = val;
@@ -XXX,XX +XXX,XX @@ set_rx_control(E1000State *s, int index, uint32_t val)
     s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1;
     DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT],
            s->mac_reg[RCTL]);
-    qemu_flush_queued_packets(qemu_get_queue(s->nic));
+    timer_mod(s->flush_queue_timer,
+              qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 1000);
 }
 
 static void
@@ -XXX,XX +XXX,XX @@ e1000_can_receive(NetClientState *nc)
     E1000State *s = qemu_get_nic_opaque(nc);
 
     return e1000x_rx_ready(&s->parent_obj, s->mac_reg) &&
-        e1000_has_rxbufs(s, 1);
+        e1000_has_rxbufs(s, 1) && !timer_pending(s->flush_queue_timer);
 }
 
 static uint64_t rx_desc_base(E1000State *s)
@@ -XXX,XX +XXX,XX @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt)
         return -1;
     }
 
+    if (timer_pending(s->flush_queue_timer)) {
+        return 0;
+    }
+
     /* Pad to minimum Ethernet frame length */
     if (size < sizeof(min_buf)) {
         iov_to_buf(iov, iovcnt, 0, min_buf, size);
@@ -XXX,XX +XXX,XX @@ pci_e1000_uninit(PCIDevice *dev)
     timer_free(d->autoneg_timer);
     timer_del(d->mit_timer);
     timer_free(d->mit_timer);
+    timer_del(d->flush_queue_timer);
+    timer_free(d->flush_queue_timer);
     qemu_del_nic(d->nic);
 }
 
@@ -XXX,XX +XXX,XX @@ static void pci_e1000_realize(PCIDevice *pci_dev, Error **errp)
 
     d->autoneg_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, e1000_autoneg_timer, d);
     d->mit_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, e1000_mit_timer, d);
+    d->flush_queue_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
+                                        e1000_flush_queue_timer, d);
 }
 
 static void qdev_e1000_reset(DeviceState *dev)
-- 
2.5.0

From: Li Qiang <liq3ea@gmail.com>

The fcntl will change the flags directly, use qemu_set_nonblock()
instead.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Li Qiang <liq3ea@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/tap.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/net/tap.c b/net/tap.c
index XXXXXXX..XXXXXXX 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -XXX,XX +XXX,XX @@ int net_init_bridge(const Netdev *netdev, const char *name,
         return -1;
     }
 
-    fcntl(fd, F_SETFL, O_NONBLOCK);
+    qemu_set_nonblock(fd);
     vnet_hdr = tap_probe_vnet_hdr(fd);
     s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
 
@@ -XXX,XX +XXX,XX @@ static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
                 }
                 return;
             }
-            fcntl(vhostfd, F_SETFL, O_NONBLOCK);
+            qemu_set_nonblock(vhostfd);
         }
         options.opaque = (void *)(uintptr_t)vhostfd;
 
@@ -XXX,XX +XXX,XX @@ int net_init_tap(const Netdev *netdev, const char *name,
             return -1;
         }
 
-        fcntl(fd, F_SETFL, O_NONBLOCK);
+        qemu_set_nonblock(fd);
 
         vnet_hdr = tap_probe_vnet_hdr(fd);
 
@@ -XXX,XX +XXX,XX @@ int net_init_tap(const Netdev *netdev, const char *name,
                 goto free_fail;
             }
 
-            fcntl(fd, F_SETFL, O_NONBLOCK);
+            qemu_set_nonblock(fd);
 
             if (i == 0) {
                 vnet_hdr = tap_probe_vnet_hdr(fd);
@@ -XXX,XX +XXX,XX @@ free_fail:
             return -1;
         }
 
-        fcntl(fd, F_SETFL, O_NONBLOCK);
+        qemu_set_nonblock(fd);
         vnet_hdr = tap_probe_vnet_hdr(fd);
 
         net_init_tap_one(tap, peer, "bridge", name, ifname,
-- 
2.5.0

The following changes since commit b6179aaff961627fcb59d7b234297966b81ac726:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-cocoa-20190304' into staging (2019-03-04 16:50:41 +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 4b9b70000218640a42c3ea908a12665e5840b6cd:

tests: Add a test for qemu self announcements (2019-03-05 11:27:41 +0800)

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

Changes from V1:
- build fixes for qmp controlled announcing

----------------------------------------------------------------
Dr. David Alan Gilbert (9):
      net: Introduce announce timer
      migration: Add announce parameters
      virtio-net: Switch to using announce timer
      migration: Switch to using announce timer
      net: Add a network device specific self-announcement ability
      virtio-net: Allow qemu_announce_self to trigger virtio announcements
      qmp: Add announce-self command
      hmp: Add hmp_announce_self
      tests: Add a test for qemu self announcements

Vincenzo Maffione (3):
      net: netmap: small improvements netmap_send()
      net: netmap: simplify netmap_receive()
      net: netmap: improve netmap_receive_iov()

Zhang Chen (1):
      net/colo-compare.c: Remove duplicated code

From: Zhang Chen <chen.zhang@intel.com>

Fix duplicated code:
https://bugs.launchpad.net/qemu/+bug/1811499

Reviewed-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Zhang Chen <chen.zhang@intel.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/colo-compare.c | 8 --------
 1 file changed, 8 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 bool colo_mark_tcp_pkt(Packet *ppkt, Packet *spkt,
             return true;
         }
     }
-    if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) {
-        if (colo_compare_packet_payload(ppkt, spkt,
-                                        ppkt->header_size, spkt->header_size,
-                                        ppkt->payload_size)) {
-            *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY;
-            return true;
-        }
-    }
 
     /* one part of secondary packet payload still need to be compared */
     if (!after(ppkt->seq_end, spkt->seq_end)) {
-- 
2.5.0

From: Vincenzo Maffione <v.maffione@gmail.com>

This change improves the handling of incomplete multi-slot packets
(e.g. with the NS_MOREFRAG set), by advancing ring->head only on
complete packets. The ring->cur pointer is advanced in any case in
order to acknowledge the kernel and move the wake-up point (thus
avoiding repeated wake-ups).
Also don't be verbose when incomplete packets are found.

Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/netmap.c | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/net/netmap.c b/net/netmap.c
index XXXXXXX..XXXXXXX 100644
--- a/net/netmap.c
+++ b/net/netmap.c
@@ -XXX,XX +XXX,XX @@ static void netmap_send(void *opaque)
 {
     NetmapState *s = opaque;
     struct netmap_ring *ring = s->rx;
+    unsigned int tail = ring->tail;
 
-    /* Keep sending while there are available packets into the netmap
+    /* Keep sending while there are available slots in the netmap
        RX ring and the forwarding path towards the peer is open. */
-    while (!nm_ring_empty(ring)) {
-        uint32_t i;
+    while (ring->head != tail) {
+        uint32_t i = ring->head;
         uint32_t idx;
         bool morefrag;
         int iovcnt = 0;
         int iovsize;
 
+        /* Get a (possibly multi-slot) packet. */
         do {
-            i = ring->cur;
             idx = ring->slot[i].buf_idx;
             morefrag = (ring->slot[i].flags & NS_MOREFRAG);
-            s->iov[iovcnt].iov_base = (u_char *)NETMAP_BUF(ring, idx);
+            s->iov[iovcnt].iov_base = (void *)NETMAP_BUF(ring, idx);
             s->iov[iovcnt].iov_len = ring->slot[i].len;
             iovcnt++;
+            i = nm_ring_next(ring, i);
+        } while (i != tail && morefrag);
 
-            ring->cur = ring->head = nm_ring_next(ring, i);
-        } while (!nm_ring_empty(ring) && morefrag);
+        /* Advance ring->cur to tell the kernel that we have seen the slots. */
+        ring->cur = i;
 
-        if (unlikely(nm_ring_empty(ring) && morefrag)) {
-            RD(5, "[netmap_send] ran out of slots, with a pending"
-                   "incomplete packet\n");
+        if (unlikely(morefrag)) {
+            /* This is a truncated packet, so we can stop without releasing the
+             * incomplete slots by updating ring->head. We will hopefully
+             * re-read the complete packet the next time we are called. */
+            break;
         }
 
         iovsize = qemu_sendv_packet_async(&s->nc, s->iov, iovcnt,
                                             netmap_send_completed);
 
+        /* Release the slots to the kernel. */
+        ring->head = i;
+
         if (iovsize == 0) {
             /* The peer does not receive anymore. Packet is queued, stop
-             * reading from the backend until netmap_send_completed()
-             */
+             * reading from the backend until netmap_send_completed(). */
             netmap_read_poll(s, false);
             break;
         }
-- 
2.5.0

From: Vincenzo Maffione <v.maffione@gmail.com>

Improve code reuse by implementing netmap_receive() with a call
to netmap_receive_iov().

Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/netmap.c | 50 +++++++++++---------------------------------------
 1 file changed, 11 insertions(+), 39 deletions(-)

diff --git a/net/netmap.c b/net/netmap.c
index XXXXXXX..XXXXXXX 100644
--- a/net/netmap.c
+++ b/net/netmap.c
@@ -XXX,XX +XXX,XX @@ static void netmap_writable(void *opaque)
     qemu_flush_queued_packets(&s->nc);
 }
 
-static ssize_t netmap_receive(NetClientState *nc,
-      const uint8_t *buf, size_t size)
-{
-    NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
-    struct netmap_ring *ring = s->tx;
-    uint32_t i;
-    uint32_t idx;
-    uint8_t *dst;
-
-    if (unlikely(!ring)) {
-        /* Drop. */
-        return size;
-    }
-
-    if (unlikely(size > ring->nr_buf_size)) {
-        RD(5, "[netmap_receive] drop packet of size %d > %d\n",
-                                    (int)size, ring->nr_buf_size);
-        return size;
-    }
-
-    if (nm_ring_empty(ring)) {
-        /* No available slots in the netmap TX ring. */
-        netmap_write_poll(s, true);
-        return 0;
-    }
-
-    i = ring->cur;
-    idx = ring->slot[i].buf_idx;
-    dst = (uint8_t *)NETMAP_BUF(ring, idx);
-
-    ring->slot[i].len = size;
-    ring->slot[i].flags = 0;
-    pkt_copy(buf, dst, size);
-    ring->cur = ring->head = nm_ring_next(ring, i);
-    ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
-
-    return size;
-}
-
 static ssize_t netmap_receive_iov(NetClientState *nc,
                     const struct iovec *iov, int iovcnt)
 {
@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
     return iov_size(iov, iovcnt);
 }
 
+static ssize_t netmap_receive(NetClientState *nc,
+      const uint8_t *buf, size_t size)
+{
+    struct iovec iov;
+
+    iov.iov_base = (void *)buf;
+    iov.iov_len = size;
+
+    return netmap_receive_iov(nc, &iov, 1);
+}
+
 /* Complete a previous send (backend --> guest) and enable the
    fd_read callback. */
 static void netmap_send_completed(NetClientState *nc, ssize_t len)
-- 
2.5.0

From: Vincenzo Maffione <v.maffione@gmail.com>

Changes:
  - Save CPU cycles by computing the return value while scanning the
    input iovec, rather than calling iov_size() at the end.
  - Remove check for s->tx != NULL, because it cannot happen.
  - Cache ring->tail in a local variable and use it to check for
    space in the TX ring. The use of nm_ring_empty() was invalid,
    because nobody is updating ring->cur and ring->head at that point.
  - In case we run out of netmap slots in the middle of a packet,
    move the wake-up point by advancing ring->cur, but do not
    expose the incomplete packet (i.e., by updating also ring->head).

Signed-off-by: Vincenzo Maffione <v.maffione@gmail.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/netmap.c | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/net/netmap.c b/net/netmap.c
index XXXXXXX..XXXXXXX 100644
--- a/net/netmap.c
+++ b/net/netmap.c
@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
 {
     NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
     struct netmap_ring *ring = s->tx;
+    unsigned int tail = ring->tail;
+    ssize_t totlen = 0;
     uint32_t last;
     uint32_t idx;
     uint8_t *dst;
     int j;
     uint32_t i;
 
-    if (unlikely(!ring)) {
-        /* Drop the packet. */
-        return iov_size(iov, iovcnt);
-    }
-
-    last = i = ring->cur;
+    last = i = ring->head;
 
     if (nm_ring_space(ring) < iovcnt) {
-        /* Not enough netmap slots. */
+        /* Not enough netmap slots. Tell the kernel that we have seen the new
+         * available slots (so that it notifies us again when it has more
+         * ones), but without publishing any new slots to be processed
+         * (e.g., we don't advance ring->head). */
+        ring->cur = tail;
         netmap_write_poll(s, true);
         return 0;
     }
@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
         int offset = 0;
         int nm_frag_size;
 
+        totlen += iov_frag_size;
+
         /* Split each iovec fragment over more netmap slots, if
            necessary. */
         while (iov_frag_size) {
             nm_frag_size = MIN(iov_frag_size, ring->nr_buf_size);
 
-            if (unlikely(nm_ring_empty(ring))) {
-                /* We run out of netmap slots while splitting the
+            if (unlikely(i == tail)) {
+                /* We ran out of netmap slots while splitting the
                    iovec fragments. */
+                ring->cur = tail;
                 netmap_write_poll(s, true);
                 return 0;
             }
@@ -XXX,XX +XXX,XX @@ static ssize_t netmap_receive_iov(NetClientState *nc,
     /* The last slot must not have NS_MOREFRAG set. */
     ring->slot[last].flags &= ~NS_MOREFRAG;
 
-    /* Now update ring->cur and ring->head. */
-    ring->cur = ring->head = i;
+    /* Now update ring->head and ring->cur to publish the new slots and
+     * the new wakeup point. */
+    ring->head = ring->cur = i;
 
     ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
 
-    return iov_size(iov, iovcnt);
+    return totlen;
 }
 
 static ssize_t netmap_receive(NetClientState *nc,
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

The 'announce timer' will be used by migration, and explicit
requests for qemu to perform network announces.

Based on the work by Germano Veit Michel <germano@redhat.com>
 and Vlad Yasevich <vyasevic@redhat.com>

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/announce.h  | 39 ++++++++++++++++++++++++++++++++
 include/qemu/typedefs.h |  1 +
 migration/migration.c   |  1 +
 net/Makefile.objs       |  1 +
 net/announce.c          | 60 +++++++++++++++++++++++++++++++++++++++++++++++++
 qapi/net.json           | 23 +++++++++++++++++++
 6 files changed, 125 insertions(+)
 create mode 100644 include/net/announce.h
 create mode 100644 net/announce.c

diff --git a/include/net/announce.h b/include/net/announce.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/net/announce.h
@@ -XXX,XX +XXX,XX @@
+/*
+ *  Self-announce facility
+ *  (c) 2017-2019 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef QEMU_NET_ANNOUNCE_H
+#define QEMU_NET_ANNOUNCE_H
+
+#include "qemu-common.h"
+#include "qapi/qapi-types-net.h"
+#include "qemu/timer.h"
+
+struct AnnounceTimer {
+    QEMUTimer *tm;
+    AnnounceParameters params;
+    QEMUClockType type;
+    int round;
+};
+
+/* Returns: update the timer to the next time point */
+int64_t qemu_announce_timer_step(AnnounceTimer *timer);
+
+/* Delete the underlying timer */
+void qemu_announce_timer_del(AnnounceTimer *timer);
+
+/*
+ * Under BQL/main thread
+ * Reset the timer to the given parameters/type/notifier.
+ */
+void qemu_announce_timer_reset(AnnounceTimer *timer,
+                               AnnounceParameters *params,
+                               QEMUClockType type,
+                               QEMUTimerCB *cb,
+                               void *opaque);
+
+#endif
diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/typedefs.h
+++ b/include/qemu/typedefs.h
@@ -XXX,XX +XXX,XX @@
 typedef struct AdapterInfo AdapterInfo;
 typedef struct AddressSpace AddressSpace;
 typedef struct AioContext AioContext;
+typedef struct AnnounceTimer AnnounceTimer;
 typedef struct BdrvDirtyBitmap BdrvDirtyBitmap;
 typedef struct BdrvDirtyBitmapIter BdrvDirtyBitmapIter;
 typedef struct BlockBackend BlockBackend;
diff --git a/migration/migration.c b/migration/migration.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@
 #include "migration/colo.h"
 #include "hw/boards.h"
 #include "monitor/monitor.h"
+#include "net/announce.h"
 
 #define MAX_THROTTLE  (32 << 20)      /* Migration transfer speed throttling */
 
diff --git a/net/Makefile.objs b/net/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/net/Makefile.objs
+++ b/net/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-y = net.o queue.o checksum.o util.o hub.o
 common-obj-y += socket.o
 common-obj-y += dump.o
 common-obj-y += eth.o
+common-obj-y += announce.o
 common-obj-$(CONFIG_L2TPV3) += l2tpv3.o
 common-obj-$(call land,$(CONFIG_VIRTIO_NET),$(CONFIG_VHOST_NET_USER)) += vhost-user.o
 common-obj-$(call land,$(call lnot,$(CONFIG_VIRTIO_NET)),$(CONFIG_VHOST_NET_USER)) += vhost-user-stub.o
diff --git a/net/announce.c b/net/announce.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@
+/*
+ *  Self-announce
+ *  (c) 2017-2019 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "net/announce.h"
+#include "qapi/clone-visitor.h"
+#include "qapi/qapi-visit-net.h"
+
+int64_t qemu_announce_timer_step(AnnounceTimer *timer)
+{
+    int64_t step;
+
+    step =  timer->params.initial +
+            (timer->params.rounds - timer->round - 1) *
+            timer->params.step;
+
+    if (step < 0 || step > timer->params.max) {
+        step = timer->params.max;
+    }
+    timer_mod(timer->tm, qemu_clock_get_ms(timer->type) + step);
+
+    return step;
+}
+
+void qemu_announce_timer_del(AnnounceTimer *timer)
+{
+    if (timer->tm) {
+        timer_del(timer->tm);
+        timer_free(timer->tm);
+        timer->tm = NULL;
+    }
+}
+
+/*
+ * Under BQL/main thread
+ * Reset the timer to the given parameters/type/notifier.
+ */
+void qemu_announce_timer_reset(AnnounceTimer *timer,
+                               AnnounceParameters *params,
+                               QEMUClockType type,
+                               QEMUTimerCB *cb,
+                               void *opaque)
+{
+    /*
+     * We're under the BQL, so the current timer can't
+     * be firing, so we should be able to delete it.
+     */
+    qemu_announce_timer_del(timer);
+
+    QAPI_CLONE_MEMBERS(AnnounceParameters, &timer->params, params);
+    timer->round = params->rounds;
+    timer->type = type;
+    timer->tm = timer_new_ms(type, cb, opaque);
+}
diff --git a/qapi/net.json b/qapi/net.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -XXX,XX +XXX,XX @@
 ##
 { 'event': 'NIC_RX_FILTER_CHANGED',
   'data': { '*name': 'str', 'path': 'str' } }
+
+##
+# @AnnounceParameters:
+#
+# Parameters for self-announce timers
+#
+# @initial: Initial delay (in ms) before sending the first GARP/RARP
+#       announcement
+#
+# @max: Maximum delay (in ms) between GARP/RARP announcement packets
+#
+# @rounds: Number of self-announcement attempts
+#
+# @step: Delay increase (in ms) after each self-announcement attempt
+#
+# Since: 4.0
+##
+
+{ 'struct': 'AnnounceParameters',
+  'data': { 'initial': 'int',
+            'max': 'int',
+            'rounds': 'int',
+            'step': 'int' } }
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Add migration parameters that control RARP/GARP announcement timeouts.

Based on earlier patches by myself and
  Vladislav Yasevich <vyasevic@redhat.com>

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hmp.c                    |  28 +++++++++++++
 include/migration/misc.h |   2 +
 migration/migration.c    | 100 +++++++++++++++++++++++++++++++++++++++++++++++
 qapi/migration.json      |  53 +++++++++++++++++++++++--
 4 files changed, 180 insertions(+), 3 deletions(-)

diff --git a/hmp.c b/hmp.c
index XXXXXXX..XXXXXXX 100644
--- a/hmp.c
+++ b/hmp.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
     params = qmp_query_migrate_parameters(NULL);
 
     if (params) {
+        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
+            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL),
+            params->announce_initial);
+        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
+            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX),
+            params->announce_max);
+        monitor_printf(mon, "%s: %" PRIu64 "\n",
+            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS),
+            params->announce_rounds);
+        monitor_printf(mon, "%s: %" PRIu64 " ms\n",
+            MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP),
+            params->announce_step);
         assert(params->has_compress_level);
         monitor_printf(mon, "%s: %u\n",
             MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL),
@@ -XXX,XX +XXX,XX @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
         p->has_max_postcopy_bandwidth = true;
         visit_type_size(v, param, &p->max_postcopy_bandwidth, &err);
         break;
+    case MIGRATION_PARAMETER_ANNOUNCE_INITIAL:
+        p->has_announce_initial = true;
+        visit_type_size(v, param, &p->announce_initial, &err);
+        break;
+    case MIGRATION_PARAMETER_ANNOUNCE_MAX:
+        p->has_announce_max = true;
+        visit_type_size(v, param, &p->announce_max, &err);
+        break;
+    case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS:
+        p->has_announce_rounds = true;
+        visit_type_size(v, param, &p->announce_rounds, &err);
+        break;
+    case MIGRATION_PARAMETER_ANNOUNCE_STEP:
+        p->has_announce_step = true;
+        visit_type_size(v, param, &p->announce_step, &err);
+        break;
     default:
         assert(0);
     }
diff --git a/include/migration/misc.h b/include/migration/misc.h
index XXXXXXX..XXXXXXX 100644
--- a/include/migration/misc.h
+++ b/include/migration/misc.h
@@ -XXX,XX +XXX,XX @@
 #define MIGRATION_MISC_H
 
 #include "qemu/notify.h"
+#include "qapi/qapi-types-net.h"
 
 /* migration/ram.c */
 
@@ -XXX,XX +XXX,XX @@ int64_t self_announce_delay(int round)
     return 50 + (SELF_ANNOUNCE_ROUNDS - round - 1) * 100;
 }
 
+AnnounceParameters *migrate_announce_params(void);
 /* migration/savevm.c */
 
 void dump_vmstate_json_to_file(FILE *out_fp);
diff --git a/migration/migration.c b/migration/migration.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@
  */
 #define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0
 
+/*
+ * Parameters for self_announce_delay giving a stream of RARP/ARP
+ * packets after migration.
+ */
+#define DEFAULT_MIGRATE_ANNOUNCE_INITIAL  50
+#define DEFAULT_MIGRATE_ANNOUNCE_MAX     550
+#define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS    5
+#define DEFAULT_MIGRATE_ANNOUNCE_STEP    100
+
 static NotifierList migration_state_notifiers =
     NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
 
@@ -XXX,XX +XXX,XX @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp)
     params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;
     params->has_max_cpu_throttle = true;
     params->max_cpu_throttle = s->parameters.max_cpu_throttle;
+    params->has_announce_initial = true;
+    params->announce_initial = s->parameters.announce_initial;
+    params->has_announce_max = true;
+    params->announce_max = s->parameters.announce_max;
+    params->has_announce_rounds = true;
+    params->announce_rounds = s->parameters.announce_rounds;
+    params->has_announce_step = true;
+    params->announce_step = s->parameters.announce_step;
 
     return params;
 }
 
+AnnounceParameters *migrate_announce_params(void)
+{
+    static AnnounceParameters ap;
+
+    MigrationState *s = migrate_get_current();
+
+    ap.initial = s->parameters.announce_initial;
+    ap.max = s->parameters.announce_max;
+    ap.rounds = s->parameters.announce_rounds;
+    ap.step = s->parameters.announce_step;
+
+    return &ap;
+}
+
 /*
  * Return true if we're already in the middle of a migration
  * (i.e. any of the active or setup states)
@@ -XXX,XX +XXX,XX @@ static bool migrate_params_check(MigrationParameters *params, Error **errp)
         return false;
     }
 
+    if (params->has_announce_initial &&
+        params->announce_initial > 100000) {
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
+                   "announce_initial",
+                   "is invalid, it must be less than 100000 ms");
+        return false;
+    }
+    if (params->has_announce_max &&
+        params->announce_max > 100000) {
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
+                   "announce_max",
+                   "is invalid, it must be less than 100000 ms");
+       return false;
+    }
+    if (params->has_announce_rounds &&
+        params->announce_rounds > 1000) {
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
+                   "announce_rounds",
+                   "is invalid, it must be in the range of 0 to 1000");
+       return false;
+    }
+    if (params->has_announce_step &&
+        (params->announce_step < 1 ||
+        params->announce_step > 10000)) {
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
+                   "announce_step",
+                   "is invalid, it must be in the range of 1 to 10000 ms");
+       return false;
+    }
     return true;
 }
 
@@ -XXX,XX +XXX,XX @@ static void migrate_params_test_apply(MigrateSetParameters *params,
     if (params->has_max_cpu_throttle) {
         dest->max_cpu_throttle = params->max_cpu_throttle;
     }
+    if (params->has_announce_initial) {
+        dest->announce_initial = params->announce_initial;
+    }
+    if (params->has_announce_max) {
+        dest->announce_max = params->announce_max;
+    }
+    if (params->has_announce_rounds) {
+        dest->announce_rounds = params->announce_rounds;
+    }
+    if (params->has_announce_step) {
+        dest->announce_step = params->announce_step;
+    }
 }
 
 static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
     if (params->has_max_cpu_throttle) {
         s->parameters.max_cpu_throttle = params->max_cpu_throttle;
     }
+    if (params->has_announce_initial) {
+        s->parameters.announce_initial = params->announce_initial;
+    }
+    if (params->has_announce_max) {
+        s->parameters.announce_max = params->announce_max;
+    }
+    if (params->has_announce_rounds) {
+        s->parameters.announce_rounds = params->announce_rounds;
+    }
+    if (params->has_announce_step) {
+        s->parameters.announce_step = params->announce_step;
+    }
 }
 
 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
@@ -XXX,XX +XXX,XX @@ static Property migration_properties[] = {
     DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,
                       parameters.max_cpu_throttle,
                       DEFAULT_MIGRATE_MAX_CPU_THROTTLE),
+    DEFINE_PROP_SIZE("announce-initial", MigrationState,
+                      parameters.announce_initial,
+                      DEFAULT_MIGRATE_ANNOUNCE_INITIAL),
+    DEFINE_PROP_SIZE("announce-max", MigrationState,
+                      parameters.announce_max,
+                      DEFAULT_MIGRATE_ANNOUNCE_MAX),
+    DEFINE_PROP_SIZE("announce-rounds", MigrationState,
+                      parameters.announce_rounds,
+                      DEFAULT_MIGRATE_ANNOUNCE_ROUNDS),
+    DEFINE_PROP_SIZE("announce-step", MigrationState,
+                      parameters.announce_step,
+                      DEFAULT_MIGRATE_ANNOUNCE_STEP),
 
     /* Migration capabilities */
     DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
@@ -XXX,XX +XXX,XX @@ static void migration_instance_init(Object *obj)
     params->has_xbzrle_cache_size = true;
     params->has_max_postcopy_bandwidth = true;
     params->has_max_cpu_throttle = true;
+    params->has_announce_initial = true;
+    params->has_announce_max = true;
+    params->has_announce_rounds = true;
+    params->has_announce_step = true;
 
     qemu_sem_init(&ms->postcopy_pause_sem, 0);
     qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);
diff --git a/qapi/migration.json b/qapi/migration.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/migration.json
+++ b/qapi/migration.json
@@ -XXX,XX +XXX,XX @@
 #
 # Migration parameters enumeration
 #
+# @announce-initial: Initial delay (in milliseconds) before sending the first
+#          announce (Since 4.0)
+#
+# @announce-max: Maximum delay (in milliseconds) between packets in the
+#          announcement (Since 4.0)
+#
+# @announce-rounds: Number of self-announce packets sent after migration
+#          (Since 4.0)
+#
+# @announce-step: Increase in delay (in milliseconds) between subsequent
+#          packets in the announcement (Since 4.0)
+#
 # @compress-level: Set the compression level to be used in live migration,
 #          the compression level is an integer between 0 and 9, where 0 means
 #          no compression, 1 means the best compression speed, and 9 means best
@@ -XXX,XX +XXX,XX @@
 #
 # @max-cpu-throttle: maximum cpu throttle percentage.
 #                    Defaults to 99. (Since 3.1)
+#
 # Since: 2.4
 ##
 { 'enum': 'MigrationParameter',
-  'data': ['compress-level', 'compress-threads', 'decompress-threads',
+  'data': ['announce-initial', 'announce-max',
+           'announce-rounds', 'announce-step',
+           'compress-level', 'compress-threads', 'decompress-threads',
            'compress-wait-thread',
            'cpu-throttle-initial', 'cpu-throttle-increment',
            'tls-creds', 'tls-hostname', 'max-bandwidth',
@@ -XXX,XX +XXX,XX @@
 ##
 # @MigrateSetParameters:
 #
+# @announce-initial: Initial delay (in milliseconds) before sending the first
+#          announce (Since 4.0)
+#
+# @announce-max: Maximum delay (in milliseconds) between packets in the
+#          announcement (Since 4.0)
+#
+# @announce-rounds: Number of self-announce packets sent after migration
+#          (Since 4.0)
+#
+# @announce-step: Increase in delay (in milliseconds) between subsequent
+#          packets in the announcement (Since 4.0)
+#
 # @compress-level: compression level
 #
 # @compress-threads: compression thread count
@@ -XXX,XX +XXX,XX @@
 # TODO either fuse back into MigrationParameters, or make
 # MigrationParameters members mandatory
 { 'struct': 'MigrateSetParameters',
-  'data': { '*compress-level': 'int',
+  'data': { '*announce-initial': 'size',
+            '*announce-max': 'size',
+            '*announce-rounds': 'size',
+            '*announce-step': 'size',
+            '*compress-level': 'int',
             '*compress-threads': 'int',
             '*compress-wait-thread': 'bool',
             '*decompress-threads': 'int',
@@ -XXX,XX +XXX,XX @@
 #
 # The optional members aren't actually optional.
 #
+# @announce-initial: Initial delay (in milliseconds) before sending the
+#          first announce (Since 4.0)
+#
+# @announce-max: Maximum delay (in milliseconds) between packets in the
+#          announcement (Since 4.0)
+#
+# @announce-rounds: Number of self-announce packets sent after migration
+#          (Since 4.0)
+#
+# @announce-step: Increase in delay (in milliseconds) between subsequent
+#          packets in the announcement (Since 4.0)
+#
 # @compress-level: compression level
 #
 # @compress-threads: compression thread count
@@ -XXX,XX +XXX,XX @@
 # Since: 2.4
 ##
 { 'struct': 'MigrationParameters',
-  'data': { '*compress-level': 'uint8',
+  'data': { '*announce-initial': 'size',
+            '*announce-max': 'size',
+            '*announce-rounds': 'size',
+            '*announce-step': 'size',
+            '*compress-level': 'uint8',
             '*compress-threads': 'uint8',
             '*compress-wait-thread': 'bool',
             '*decompress-threads': 'uint8',
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Switch virtio's self announcement to use the AnnounceTimer.
It keeps it's own AnnounceTimer (per device), and starts running it
using a migration post-load and a virtual clock; that way the
announce happens once the guest is actually running.
The timer uses the migration parameters to set the timing of
the repeats.

Based on earlier patches by myself and
 Vladislav Yasevich <vyasevic@redhat.com>

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/trace-events            |  5 +++++
 hw/net/virtio-net.c            | 36 +++++++++++++++++++++++-------------
 include/hw/virtio/virtio-net.h |  4 ++--
 3 files changed, 30 insertions(+), 15 deletions(-)

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 @@ sunhme_rx_filter_reject(void) "rejecting incoming frame"
 sunhme_rx_filter_accept(void) "accepting incoming frame"
 sunhme_rx_desc(uint32_t addr, int offset, uint32_t status, int len, int cr, int nr) "addr 0x%"PRIx32"(+0x%x) status 0x%"PRIx32 " len %d (ring %d/%d)"
 sunhme_rx_xsum_calc(uint16_t xsum) "calculated incoming xsum as 0x%x"
+
+# hw/net/virtio-net.c
+virtio_net_announce_timer(int round) "%d"
+virtio_net_handle_announce(int round) "%d"
+virtio_net_post_load_device(void)
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 @@
 #include "qemu/timer.h"
 #include "hw/virtio/virtio-net.h"
 #include "net/vhost_net.h"
+#include "net/announce.h"
 #include "hw/virtio/virtio-bus.h"
 #include "qapi/error.h"
 #include "qapi/qapi-events-net.h"
 #include "hw/virtio/virtio-access.h"
 #include "migration/misc.h"
 #include "standard-headers/linux/ethtool.h"
+#include "trace.h"
 
 #define VIRTIO_NET_VM_VERSION    11
 
@@ -XXX,XX +XXX,XX @@ static void virtio_net_announce_timer(void *opaque)
 {
     VirtIONet *n = opaque;
     VirtIODevice *vdev = VIRTIO_DEVICE(n);
+    trace_virtio_net_announce_timer(n->announce_timer.round);
 
-    n->announce_counter--;
+    n->announce_timer.round--;
     n->status |= VIRTIO_NET_S_ANNOUNCE;
     virtio_notify_config(vdev);
 }
@@ -XXX,XX +XXX,XX @@ static void virtio_net_reset(VirtIODevice *vdev)
     n->nobcast = 0;
     /* multiqueue is disabled by default */
     n->curr_queues = 1;
-    timer_del(n->announce_timer);
-    n->announce_counter = 0;
+    timer_del(n->announce_timer.tm);
+    n->announce_timer.round = 0;
     n->status &= ~VIRTIO_NET_S_ANNOUNCE;
 
     /* Flush any MAC and VLAN filter table state */
@@ -XXX,XX +XXX,XX @@ static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
 static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
                                       struct iovec *iov, unsigned int iov_cnt)
 {
+    trace_virtio_net_handle_announce(n->announce_timer.round);
     if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
         n->status & VIRTIO_NET_S_ANNOUNCE) {
         n->status &= ~VIRTIO_NET_S_ANNOUNCE;
-        if (n->announce_counter) {
-            timer_mod(n->announce_timer,
-                      qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
-                      self_announce_delay(n->announce_counter));
+        if (n->announce_timer.round) {
+            qemu_announce_timer_step(&n->announce_timer);
         }
         return VIRTIO_NET_OK;
     } else {
@@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id)
     VirtIODevice *vdev = VIRTIO_DEVICE(n);
     int i, link_down;
 
+    trace_virtio_net_post_load_device();
     virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
                                virtio_vdev_has_feature(vdev,
                                                        VIRTIO_F_VERSION_1));
@@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id)
 
     if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
         virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
-        n->announce_counter = SELF_ANNOUNCE_ROUNDS;
-        timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));
+        qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
+                                  QEMU_CLOCK_VIRTUAL,
+                                  virtio_net_announce_timer, n);
+        if (n->announce_timer.round) {
+            timer_mod(n->announce_timer.tm,
+                      qemu_clock_get_ms(n->announce_timer.type));
+        } else {
+            qemu_announce_timer_del(&n->announce_timer);
+        }
     }
 
     return 0;
@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
     qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
     memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
     n->status = VIRTIO_NET_S_LINK_UP;
-    n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
-                                     virtio_net_announce_timer, n);
+    qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
+                              QEMU_CLOCK_VIRTUAL,
+                              virtio_net_announce_timer, n);
 
     if (n->netclient_type) {
         /*
@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
         virtio_net_del_queue(n, i);
     }
 
-    timer_del(n->announce_timer);
-    timer_free(n->announce_timer);
+    qemu_announce_timer_del(&n->announce_timer);
     g_free(n->vqs);
     qemu_del_nic(n->nic);
     virtio_net_rsc_cleanup(n);
diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio-net.h
+++ b/include/hw/virtio/virtio-net.h
@@ -XXX,XX +XXX,XX @@
 #include "qemu/units.h"
 #include "standard-headers/linux/virtio_net.h"
 #include "hw/virtio/virtio.h"
+#include "net/announce.h"
 
 #define TYPE_VIRTIO_NET "virtio-net-device"
 #define VIRTIO_NET(obj) \
@@ -XXX,XX +XXX,XX @@ struct VirtIONet {
     char *netclient_name;
     char *netclient_type;
     uint64_t curr_guest_offloads;
-    QEMUTimer *announce_timer;
-    int announce_counter;
+    AnnounceTimer announce_timer;
     bool needs_vnet_hdr_swap;
     bool mtu_bypass_backend;
 };
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Switch the announcements to using the new announce timer.
Move the code that does it to announce.c rather than savevm
because it really has nothing to do with the actual migration.

Migration starts the announce from bh's and so they're all
in the main thread/bql, and so there's never any racing with
the timers themselves.

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/migration/misc.h | 10 -------
 include/net/announce.h   |  2 ++
 include/sysemu/sysemu.h  |  2 --
 migration/migration.c    |  2 +-
 migration/migration.h    |  4 +++
 migration/savevm.c       | 72 ++----------------------------------------------
 migration/trace-events   |  1 -
 net/announce.c           | 68 +++++++++++++++++++++++++++++++++++++++++++++
 net/trace-events         |  3 ++
 9 files changed, 81 insertions(+), 83 deletions(-)

diff --git a/include/migration/misc.h b/include/migration/misc.h
index XXXXXXX..XXXXXXX 100644
--- a/include/migration/misc.h
+++ b/include/migration/misc.h
@@ -XXX,XX +XXX,XX @@ void blk_mig_init(void);
 static inline void blk_mig_init(void) {}
 #endif
 
-#define SELF_ANNOUNCE_ROUNDS 5
-
-static inline
-int64_t self_announce_delay(int round)
-{
-    assert(round < SELF_ANNOUNCE_ROUNDS && round > 0);
-    /* delay 50ms, 150ms, 250ms, ... */
-    return 50 + (SELF_ANNOUNCE_ROUNDS - round - 1) * 100;
-}
-
 AnnounceParameters *migrate_announce_params(void);
 /* migration/savevm.c */
 
diff --git a/include/net/announce.h b/include/net/announce.h
index XXXXXXX..XXXXXXX 100644
--- a/include/net/announce.h
+++ b/include/net/announce.h
@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_reset(AnnounceTimer *timer,
                                QEMUTimerCB *cb,
                                void *opaque);
 
+void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params);
+
 #endif
diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/sysemu.h
+++ b/include/sysemu/sysemu.h
@@ -XXX,XX +XXX,XX @@ extern bool machine_init_done;
 void qemu_add_machine_init_done_notifier(Notifier *notify);
 void qemu_remove_machine_init_done_notifier(Notifier *notify);
 
-void qemu_announce_self(void);
-
 extern int autostart;
 
 typedef enum {
diff --git a/migration/migration.c b/migration/migration.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@ static void process_incoming_migration_bh(void *opaque)
      * This must happen after all error conditions are dealt with and
      * we're sure the VM is going to be running on this host.
      */
-    qemu_announce_self();
+    qemu_announce_self(&mis->announce_timer, migrate_announce_params());
 
     if (multifd_load_cleanup(&local_err) != 0) {
         error_report_err(local_err);
diff --git a/migration/migration.h b/migration/migration.h
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.h
+++ b/migration/migration.h
@@ -XXX,XX +XXX,XX @@
 #include "qemu/coroutine_int.h"
 #include "hw/qdev.h"
 #include "io/channel.h"
+#include "net/announce.h"
 
 struct PostcopyBlocktimeContext;
 
@@ -XXX,XX +XXX,XX @@ struct MigrationIncomingState {
      */
     QemuEvent main_thread_load_event;
 
+    /* For network announces */
+    AnnounceTimer  announce_timer;
+
     size_t         largest_page_size;
     bool           have_fault_thread;
     QemuThread     fault_thread;
diff --git a/migration/savevm.c b/migration/savevm.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/replay.h"
 #include "qjson.h"
 #include "migration/colo.h"
-
-#ifndef ETH_P_RARP
-#define ETH_P_RARP 0x8035
-#endif
-#define ARP_HTYPE_ETH 0x0001
-#define ARP_PTYPE_IP 0x0800
-#define ARP_OP_REQUEST_REV 0x3
+#include "net/announce.h"
 
 const unsigned int postcopy_ram_discard_version = 0;
 
@@ -XXX,XX +XXX,XX @@ static struct mig_cmd_args {
  * generic extendable format with an exception for two old entities.
  */
 
-static int announce_self_create(uint8_t *buf,
-                                uint8_t *mac_addr)
-{
-    /* Ethernet header. */
-    memset(buf, 0xff, 6);         /* destination MAC addr */
-    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
-    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
-
-    /* RARP header. */
-    *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
-    *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
-    *(buf + 18) = 6; /* hardware addr length (ethernet) */
-    *(buf + 19) = 4; /* protocol addr length (IPv4) */
-    *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
-    memcpy(buf + 22, mac_addr, 6); /* source hw addr */
-    memset(buf + 28, 0x00, 4);     /* source protocol addr */
-    memcpy(buf + 32, mac_addr, 6); /* target hw addr */
-    memset(buf + 38, 0x00, 4);     /* target protocol addr */
-
-    /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
-    memset(buf + 42, 0x00, 18);
-
-    return 60; /* len (FCS will be added by hardware) */
-}
-
-static void qemu_announce_self_iter(NICState *nic, void *opaque)
-{
-    uint8_t buf[60];
-    int len;
-
-    trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
-    len = announce_self_create(buf, nic->conf->macaddr.a);
-
-    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
-}
-
-
-static void qemu_announce_self_once(void *opaque)
-{
-    static int count = SELF_ANNOUNCE_ROUNDS;
-    QEMUTimer *timer = *(QEMUTimer **)opaque;
-
-    qemu_foreach_nic(qemu_announce_self_iter, NULL);
-
-    if (--count) {
-        /* delay 50ms, 150ms, 250ms, ... */
-        timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
-                  self_announce_delay(count));
-    } else {
-            timer_del(timer);
-            timer_free(timer);
-    }
-}
-
-void qemu_announce_self(void)
-{
-    static QEMUTimer *timer;
-    timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
-    qemu_announce_self_once(&timer);
-}
-
 /***********************************************************/
 /* savevm/loadvm support */
 
@@ -XXX,XX +XXX,XX @@ static void loadvm_postcopy_handle_run_bh(void *opaque)
 {
     Error *local_err = NULL;
     HandleRunBhData *data = opaque;
+    MigrationIncomingState *mis = migration_incoming_get_current();
 
     /* TODO we should move all of this lot into postcopy_ram.c or a shared code
      * in migration.c
      */
     cpu_synchronize_all_post_init();
 
-    qemu_announce_self();
+    qemu_announce_self(&mis->announce_timer, migrate_announce_params());
 
     /* Make sure all file formats flush their mutable metadata.
      * If we get an error here, just don't restart the VM yet. */
diff --git a/migration/trace-events b/migration/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/migration/trace-events
+++ b/migration/trace-events
@@ -XXX,XX +XXX,XX @@ vmstate_save_state_top(const char *idstr) "%s"
 vmstate_subsection_save_loop(const char *name, const char *sub) "%s/%s"
 vmstate_subsection_save_top(const char *idstr) "%s"
 vmstate_load(const char *idstr, const char *vmsd_name) "%s, %s"
-qemu_announce_self_iter(const char *mac) "%s"
 
 # migration/vmstate.c
 vmstate_load_field_error(const char *field, int ret) "field \"%s\" load failed, ret = %d"
diff --git a/net/announce.c b/net/announce.c
index XXXXXXX..XXXXXXX 100644
--- a/net/announce.c
+++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qemu-common.h"
 #include "net/announce.h"
+#include "net/net.h"
 #include "qapi/clone-visitor.h"
 #include "qapi/qapi-visit-net.h"
+#include "trace.h"
 
 int64_t qemu_announce_timer_step(AnnounceTimer *timer)
 {
@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_reset(AnnounceTimer *timer,
     timer->type = type;
     timer->tm = timer_new_ms(type, cb, opaque);
 }
+
+#ifndef ETH_P_RARP
+#define ETH_P_RARP 0x8035
+#endif
+#define ARP_HTYPE_ETH 0x0001
+#define ARP_PTYPE_IP 0x0800
+#define ARP_OP_REQUEST_REV 0x3
+
+static int announce_self_create(uint8_t *buf,
+                                uint8_t *mac_addr)
+{
+    /* Ethernet header. */
+    memset(buf, 0xff, 6);         /* destination MAC addr */
+    memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
+    *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
+
+    /* RARP header. */
+    *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
+    *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
+    *(buf + 18) = 6; /* hardware addr length (ethernet) */
+    *(buf + 19) = 4; /* protocol addr length (IPv4) */
+    *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
+    memcpy(buf + 22, mac_addr, 6); /* source hw addr */
+    memset(buf + 28, 0x00, 4);     /* source protocol addr */
+    memcpy(buf + 32, mac_addr, 6); /* target hw addr */
+    memset(buf + 38, 0x00, 4);     /* target protocol addr */
+
+    /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
+    memset(buf + 42, 0x00, 18);
+
+    return 60; /* len (FCS will be added by hardware) */
+}
+
+static void qemu_announce_self_iter(NICState *nic, void *opaque)
+{
+    uint8_t buf[60];
+    int len;
+
+    trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
+    len = announce_self_create(buf, nic->conf->macaddr.a);
+
+    qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
+}
+static void qemu_announce_self_once(void *opaque)
+{
+    AnnounceTimer *timer = (AnnounceTimer *)opaque;
+
+    qemu_foreach_nic(qemu_announce_self_iter, NULL);
+
+    if (--timer->round) {
+        qemu_announce_timer_step(timer);
+    } else {
+        qemu_announce_timer_del(timer);
+    }
+}
+
+void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
+{
+    qemu_announce_timer_reset(timer, params, QEMU_CLOCK_REALTIME,
+                              qemu_announce_self_once, timer);
+    if (params->rounds) {
+        qemu_announce_self_once(timer);
+    } else {
+        qemu_announce_timer_del(timer);
+    }
+}
diff --git a/net/trace-events b/net/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/net/trace-events
+++ b/net/trace-events
@@ -XXX,XX +XXX,XX @@
 # See docs/devel/tracing.txt for syntax documentation.
 
+# net/announce.c
+qemu_announce_self_iter(const char *mac) "%s"
+
 # net/vhost-user.c
 vhost_user_event(const char *chr, int event) "chr: %s got event: %d"
 
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Some network devices have a capability to do self announcements
(ex: virtio-net).  Add infrastructure that would allow devices
to expose this ability.

Signed-off-by: Vladislav Yasevich <vyasevic@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/net.h | 2 ++
 net/announce.c    | 5 +++++
 2 files changed, 7 insertions(+)

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 int (SetVnetLE)(NetClientState *, bool);
 typedef int (SetVnetBE)(NetClientState *, bool);
 typedef struct SocketReadState SocketReadState;
 typedef void (SocketReadStateFinalize)(SocketReadState *rs);
+typedef void (NetAnnounce)(NetClientState *);
 
 typedef struct NetClientInfo {
     NetClientDriver type;
@@ -XXX,XX +XXX,XX @@ typedef struct NetClientInfo {
     SetVnetHdrLen *set_vnet_hdr_len;
     SetVnetLE *set_vnet_le;
     SetVnetBE *set_vnet_be;
+    NetAnnounce *announce;
 } NetClientInfo;
 
 struct NetClientState {
diff --git a/net/announce.c b/net/announce.c
index XXXXXXX..XXXXXXX 100644
--- a/net/announce.c
+++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@ static void qemu_announce_self_iter(NICState *nic, void *opaque)
     len = announce_self_create(buf, nic->conf->macaddr.a);
 
     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
+
+    /* if the NIC provides it's own announcement support, use it as well */
+    if (nic->ncs->info->announce) {
+        nic->ncs->info->announce(nic->ncs);
+    }
 }
 static void qemu_announce_self_once(void *opaque)
 {
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Expose the virtio-net self announcement capability and allow
qemu_announce_self() to call it.

These announces are caused by something external (i.e. the
announce-self command); they won't trigger if the migration
counter is triggering announces at the same time.

Signed-off-by: Vladislav Yasevich <vyasevic@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/trace-events |  1 +
 hw/net/virtio-net.c | 35 ++++++++++++++++++++++++++++++++---
 2 files changed, 33 insertions(+), 3 deletions(-)

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 @@ sunhme_rx_desc(uint32_t addr, int offset, uint32_t status, int len, int cr, int
 sunhme_rx_xsum_calc(uint16_t xsum) "calculated incoming xsum as 0x%x"
 
 # hw/net/virtio-net.c
+virtio_net_announce_notify(void) ""
 virtio_net_announce_timer(int round) "%d"
 virtio_net_handle_announce(int round) "%d"
 virtio_net_post_load_device(void)
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 bool virtio_net_started(VirtIONet *n, uint8_t status)
         (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
 }
 
+static void virtio_net_announce_notify(VirtIONet *net)
+{
+    VirtIODevice *vdev = VIRTIO_DEVICE(net);
+    trace_virtio_net_announce_notify();
+
+    net->status |= VIRTIO_NET_S_ANNOUNCE;
+    virtio_notify_config(vdev);
+}
+
 static void virtio_net_announce_timer(void *opaque)
 {
     VirtIONet *n = opaque;
-    VirtIODevice *vdev = VIRTIO_DEVICE(n);
     trace_virtio_net_announce_timer(n->announce_timer.round);
 
     n->announce_timer.round--;
-    n->status |= VIRTIO_NET_S_ANNOUNCE;
-    virtio_notify_config(vdev);
+    virtio_net_announce_notify(n);
+}
+
+static void virtio_net_announce(NetClientState *nc)
+{
+    VirtIONet *n = qemu_get_nic_opaque(nc);
+    VirtIODevice *vdev = VIRTIO_DEVICE(n);
+
+    /*
+     * Make sure the virtio migration announcement timer isn't running
+     * If it is, let it trigger announcement so that we do not cause
+     * confusion.
+     */
+    if (n->announce_timer.round) {
+        return;
+    }
+
+    if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
+        virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
+            virtio_net_announce_notify(n);
+    }
 }
 
 static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_virtio_info = {
     .receive = virtio_net_receive,
     .link_status_changed = virtio_net_set_link_status,
     .query_rx_filter = virtio_net_query_rxfilter,
+    .announce = virtio_net_announce,
 };
 
 static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
     qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
                               QEMU_CLOCK_VIRTUAL,
                               virtio_net_announce_timer, n);
+    n->announce_timer.round = 0;
 
     if (n->netclient_type) {
         /*
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Add a qmp command that can trigger guest announcements.

It uses its own announce-timer instance, and parameters
passed to it explicitly in the command.

Like most qmp commands, it's in the main thread/bql, so
there's no racing with any outstanding timer.

Based on work of Germano Veit Michel <germano@redhat.com> and
                 Vladislav Yasevich <vyasevic@redhat.com>

Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/announce.c |  7 +++++++
 qapi/net.json  | 20 ++++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/net/announce.c b/net/announce.c
index XXXXXXX..XXXXXXX 100644
--- a/net/announce.c
+++ b/net/announce.c
@@ -XXX,XX +XXX,XX @@
 #include "net/net.h"
 #include "qapi/clone-visitor.h"
 #include "qapi/qapi-visit-net.h"
+#include "qapi/qapi-commands-net.h"
 #include "trace.h"
 
 int64_t qemu_announce_timer_step(AnnounceTimer *timer)
@@ -XXX,XX +XXX,XX @@ void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
         qemu_announce_timer_del(timer);
     }
 }
+
+void qmp_announce_self(AnnounceParameters *params, Error **errp)
+{
+    static AnnounceTimer announce_timer;
+    qemu_announce_self(&announce_timer, params);
+}
diff --git a/qapi/net.json b/qapi/net.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -XXX,XX +XXX,XX @@
             'max': 'int',
             'rounds': 'int',
             'step': 'int' } }
+
+##
+# @announce-self:
+#
+# Trigger generation of broadcast RARP frames to update network switches.
+# This can be useful when network bonds fail-over the active slave.
+#
+# @params: AnnounceParameters giving timing and repetition count of announce
+#
+# Example:
+#
+# -> { "execute": "announce-self"
+#      "arguments": {
+#          "initial": 50, "max": 550, "rounds": 10, "step": 50 } }
+# <- { "return": {} }
+#
+# Since: 4.0
+##
+{ 'command': 'announce-self', 'boxed': true,
+  'data' : 'AnnounceParameters'}
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Add an HMP command to trigger self annocements.
Unlike the QMP command (which takes a set of parameters), the HMP
command reuses the set of parameters used for migration.

Signend-off-by: Vladislav Yasevich <vyasevic@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hmp-commands.hx  | 16 ++++++++++++++++
 hmp.c            |  5 +++++
 hmp.h            |  1 +
 tests/test-hmp.c |  1 +
 4 files changed, 23 insertions(+)

diff --git a/hmp-commands.hx b/hmp-commands.hx
index XXXXXXX..XXXXXXX 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ stops because the size limit is reached.
 ETEXI
 
     {
+        .name       = "announce_self",
+        .args_type  = "",
+        .params     = "",
+        .help       = "Trigger GARP/RARP announcements",
+        .cmd        = hmp_announce_self,
+    },
+
+STEXI
+@item announce_self
+@findex announce_self
+Trigger a round of GARP/RARP broadcasts; this is useful for explicitly updating the
+network infrastructure after a reconfiguration or some forms of migration.
+The timings of the round are set by the migration announce parameters.
+ETEXI
+
+    {
         .name       = "migrate",
         .args_type  = "detach:-d,blk:-b,inc:-i,resume:-r,uri:s",
         .params     = "[-d] [-b] [-i] [-r] uri",
diff --git a/hmp.c b/hmp.c
index XXXXXXX..XXXXXXX 100644
--- a/hmp.c
+++ b/hmp.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
 
 }
 
+void hmp_announce_self(Monitor *mon, const QDict *qdict)
+{
+    qmp_announce_self(migrate_announce_params(), NULL);
+}
+
 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
 {
     qmp_migrate_cancel(NULL);
diff --git a/hmp.h b/hmp.h
index XXXXXXX..XXXXXXX 100644
--- a/hmp.h
+++ b/hmp.h
@@ -XXX,XX +XXX,XX @@ void hmp_sync_profile(Monitor *mon, const QDict *qdict);
 void hmp_system_reset(Monitor *mon, const QDict *qdict);
 void hmp_system_powerdown(Monitor *mon, const QDict *qdict);
 void hmp_exit_preconfig(Monitor *mon, const QDict *qdict);
+void hmp_announce_self(Monitor *mon, const QDict *qdict);
 void hmp_cpu(Monitor *mon, const QDict *qdict);
 void hmp_memsave(Monitor *mon, const QDict *qdict);
 void hmp_pmemsave(Monitor *mon, const QDict *qdict);
diff --git a/tests/test-hmp.c b/tests/test-hmp.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-hmp.c
+++ b/tests/test-hmp.c
@@ -XXX,XX +XXX,XX @@
 static int verbose;
 
 static const char *hmp_cmds[] = {
+    "announce_self",
     "boot_set ndc",
     "chardev-add null,id=testchardev1",
     "chardev-send-break testchardev1",
-- 
2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

We now expose qemu_announce_self through QMP and HMP.  Add a test
with some very basic packet validation (make sure we get a RARP).

Signed-off-by: Vlad Yasevich <vyasevic@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 tests/Makefile.include     |  3 ++
 tests/test-announce-self.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+)
 create mode 100644 tests/test-announce-self.c

diff --git a/tests/Makefile.include b/tests/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ check-qtest-i386-$(CONFIG_SLIRP) += tests/test-netfilter$(EXESUF)
 check-qtest-i386-$(CONFIG_POSIX) += tests/test-filter-mirror$(EXESUF)
 check-qtest-i386-$(CONFIG_RTL8139_PCI) += tests/test-filter-redirector$(EXESUF)
 check-qtest-i386-y += tests/migration-test$(EXESUF)
+check-qtest-i386-y += tests/test-announce-self$(EXESUF)
 check-qtest-i386-y += tests/test-x86-cpuid-compat$(EXESUF)
 check-qtest-i386-y += tests/numa-test$(EXESUF)
 check-qtest-x86_64-y += $(check-qtest-i386-y)
@@ -XXX,XX +XXX,XX @@ check-qtest-ppc64-$(CONFIG_PSERIES) += tests/spapr-phb-test$(EXESUF)
 check-qtest-ppc64-$(CONFIG_PSERIES) += tests/device-plug-test$(EXESUF)
 check-qtest-ppc64-$(CONFIG_POWERNV) += tests/pnv-xscom-test$(EXESUF)
 check-qtest-ppc64-y += tests/migration-test$(EXESUF)
+check-qtest-ppc64-y += tests/test-announce-self$(EXESUF)
 check-qtest-ppc64-$(CONFIG_PSERIES) += tests/rtas-test$(EXESUF)
 check-qtest-ppc64-$(CONFIG_SLIRP) += tests/pxe-test$(EXESUF)
 check-qtest-ppc64-$(CONFIG_USB_OHCI) += tests/usb-hcd-ohci-test$(EXESUF)
@@ -XXX,XX +XXX,XX @@ tests/usb-hcd-ehci-test$(EXESUF): tests/usb-hcd-ehci-test.o $(libqos-usb-obj-y)
 tests/usb-hcd-xhci-test$(EXESUF): tests/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
 tests/cpu-plug-test$(EXESUF): tests/cpu-plug-test.o
 tests/migration-test$(EXESUF): tests/migration-test.o
+tests/test-announce-self$(EXESUF): tests/test-announce-self.o
 tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o $(test-util-obj-y) \
 	$(qtest-obj-y) $(test-io-obj-y) $(libqos-virtio-obj-y) $(libqos-pc-obj-y) \
 	$(chardev-obj-y)
diff --git a/tests/test-announce-self.c b/tests/test-announce-self.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/test-announce-self.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QTest testcase for qemu_announce_self
+ *
+ * Copyright (c) 2017 Red hat, Inc.
+ * Copyright (c) 2014 SUSE LINUX Products GmbH
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "libqtest.h"
+#include "qapi/qmp/qdict.h"
+#include "qemu-common.h"
+#include "qemu/sockets.h"
+#include "qemu/iov.h"
+#include "libqos/libqos-pc.h"
+#include "libqos/libqos-spapr.h"
+
+#ifndef ETH_P_RARP
+#define ETH_P_RARP 0x8035
+#endif
+
+static QTestState *test_init(int socket)
+{
+    char *args;
+
+    args = g_strdup_printf("-netdev socket,fd=%d,id=hs0 -device "
+                           "virtio-net-pci,netdev=hs0", socket);
+
+    return qtest_start(args);
+}
+
+
+static void test_announce(int socket)
+{
+    char buffer[60];
+    int len;
+    QDict *rsp;
+    int ret;
+    uint16_t *proto = (uint16_t *)&buffer[12];
+
+    rsp = qmp("{ 'execute' : 'announce-self', "
+                  " 'arguments': {"
+                      " 'initial': 50, 'max': 550,"
+                      " 'rounds': 10, 'step': 50 } }");
+    assert(!qdict_haskey(rsp, "error"));
+    qobject_unref(rsp);
+
+    /* Catch the packet and make sure it's a RARP */
+    ret = qemu_recv(socket, &len, sizeof(len), 0);
+    g_assert_cmpint(ret, ==,  sizeof(len));
+    len = ntohl(len);
+
+    ret = qemu_recv(socket, buffer, len, 0);
+    g_assert_cmpint(*proto, ==, htons(ETH_P_RARP));
+}
+
+static void setup(gconstpointer data)
+{
+    QTestState *qs;
+    void (*func) (int socket) = data;
+    int sv[2], ret;
+
+    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sv);
+    g_assert_cmpint(ret, !=, -1);
+
+    qs = test_init(sv[1]);
+    func(sv[0]);
+
+    /* End test */
+    close(sv[0]);
+    qtest_quit(qs);
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+    qtest_add_data_func("/virtio/net/test_announce_self", test_announce, setup);
+
+    return g_test_run();
+}
-- 
2.5.0