Series comparison

-[Qemu-devel] [PULL 0/6] Net patches
+[PULL 00/26] Net patches
-The following changes since commit e607bbee553cfe73072870cef458cfa4e78133e2:
+The following changes since commit 344744e148e6e865f5a57e745b02a87e5ea534ad:
-  Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-01-26.for-upstream' into staging (2018-01-26 14:24:25 +0000)
+  Merge tag 'dump-pull-request' of https://gitlab.com/marcandre.lureau/qemu into staging (2022-10-26 10:53:49 -0400)
 are available in the git repository at:
   https://github.com/jasowang/qemu.git tags/net-pull-request
-for you to fetch changes up to bf4835a4d5338bb7424827715df22570a8adc67c:
+for you to fetch changes up to e506fee8b1e092f6ac6f9459bf6a35b807644ad2:
-  MAINTAINERS: update Dmitry Fleytman email (2018-01-29 16:05:38 +0800)
+  net: stream: add QAPI events to report connection state (2022-10-28 13:28:52 +0800)
 ----------------------------------------------------------------
 ----------------------------------------------------------------
-Mao Zhongyi (2):
+Daniel P. Berrangé (1):
-      colo: modified the payload compare function
+      net: improve error message for missing netdev backend
       colo: compare the packet based on the tcp sequence number
-Philippe Mathieu-Daudé (1):
+Eugenio Pérez (6):
-      MAINTAINERS: update Dmitry Fleytman email
+      vdpa: Delete duplicated vdpa_feature_bits entry
       vdpa: Remove shadow CVQ command check
       vhost: allocate event_idx fields on vring
       vhost: toggle device callbacks using used event idx
       vhost: use avail event idx on vhost_svq_kick
       vhost: Accept event idx flag
-Thomas Huth (3):
+Laurent Vivier (16):
-      net: Allow hubports to connect to other netdevs
+      virtio-net: fix bottom-half packet TX on asynchronous completion
-      net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove'
+      virtio-net: fix TX timer with tx_burst
-      qemu-doc: Get rid of "vlan=X" example in the documentation
+      net: introduce convert_host_port()
       net: remove the @errp argument of net_client_inits()
       net: simplify net_client_parse() error management
       qapi: net: introduce a way to bypass qemu_opts_parse_noisily()
       net: introduce qemu_set_info_str() function
       qapi: net: add stream and dgram netdevs
       net: stream: add unix socket
       net: dgram: make dgram_dst generic
       net: dgram: move mcast specific code from net_socket_fd_init_dgram()
       net: dgram: add unix socket
       qemu-sockets: move and rename SocketAddress_to_str()
       qemu-sockets: update socket_uri() and socket_parse() to be consistent
       net: stream: move to QIO to enable additional parameters
       net: stream: add QAPI events to report connection state
- MAINTAINERS        |   8 +-
+Si-Wei Liu (1):
- hmp-commands.hx    |   4 +-
+      vhost-vdpa: allow passing opened vhostfd to vhost-vdpa
- net/colo-compare.c | 411 +++++++++++++++++++++++++++++++++--------------------
- net/colo.c         |   9 ++
+Stefano Brivio (2):
- net/colo.h         |  15 ++
+      net: socket: Don't ignore EINVAL on netdev socket connection
- net/hub.c          |  27 +++-
+      net: stream: Don't ignore EINVAL on netdev socket connection
- net/hub.h          |   3 +-
- net/net.c          |   2 +-
+ hmp-commands.hx                    |   2 +-
- net/slirp.c        |  33 +++--
+ hw/net/virtio-net.c                |  59 +++-
- net/trace-events   |   2 +-
+ hw/net/xen_nic.c                   |   5 +-
- qapi/net.json      |   4 +-
+ hw/virtio/vhost-shadow-virtqueue.c |  39 ++-
- qemu-options.hx    |  12 +-
+ include/net/net.h                  |   7 +-
-files changed, 347 insertions(+), 183 deletions(-)
+ include/qemu/sockets.h             |   4 +-
  monitor/hmp-cmds.c                 |  23 +-
  net/clients.h                      |   6 +
  net/dgram.c                        | 623 +++++++++++++++++++++++++++++++++++++
  net/hub.c                          |   2 +
  net/l2tpv3.c                       |   3 +-
  net/meson.build                    |   2 +
  net/net.c                          | 204 ++++++++----
  net/slirp.c                        |   5 +-
  net/socket.c                       |  36 +--
  net/stream.c                       | 386 +++++++++++++++++++++++
  net/tap-win32.c                    |   3 +-
  net/tap.c                          |  13 +-
  net/vde.c                          |   3 +-
  net/vhost-user.c                   |   3 +-
  net/vhost-vdpa.c                   |  76 ++---
  qapi/net.json                      | 118 ++++++-
  qemu-options.hx                    |  20 +-
  softmmu/vl.c                       |  16 +-
  util/qemu-sockets.c                |  25 ++
 files changed, 1473 insertions(+), 210 deletions(-)
  create mode 100644 net/dgram.c
  create mode 100644 net/stream.c

-New patch
+[PULL 01/26] virtio-net: fix bottom-half packet TX on asynchronous completion
+From: Laurent Vivier <lvivier@redhat.com>
+When virtio-net is used with the socket netdev backend, the backend
+can be busy and not able to collect new packets.
+In this case, net_socket_receive() returns 0 and registers a poll function
+to detect when the socket is ready again.
+In virtio_net_tx_bh(), virtio_net_flush_tx() forwards the 0, the virtio
+notifications are disabled and the function is not re-scheduled, waiting
+for the backend to be ready.
+When the socket netdev backend is again able to send packets, the poll
+function re-starts to flush remaining packets. This is done by
+calling virtio_net_tx_complete(). It re-enables notifications and calls
+again virtio_net_flush_tx().
+But it seems if virtio_net_flush_tx() reaches the tx_burst value all
+the queue is not flushed and no new notification is sent to re-schedule
+virtio_net_tx_bh(). Nothing re-start to flush the queue and remaining
+packets are stuck in the queue.
+To fix that, detect in virtio_net_tx_complete() if virtio_net_flush_tx()
+has been stopped by tx_burst and if yes re-schedule the bottom half
+function virtio_net_tx_bh() to flush the remaining packets.
+This is what is done in virtio_net_tx_bh() when the virtio_net_flush_tx()
+is synchronous, and completly by-passed when the operation needs to be
+asynchronous.
+Fixes: a697a334b3c4 ("virtio-net: Introduce a new bottom half packet TX")
+Cc: alex.williamson@redhat.com
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/virtio-net.c | 13 ++++++++++++-
+file changed, 12 insertions(+), 1 deletion(-)
+diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/virtio-net.c
++++ b/hw/net/virtio-net.c
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
+     VirtIONet *n = qemu_get_nic_opaque(nc);
+     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
+     VirtIODevice *vdev = VIRTIO_DEVICE(n);
++    int ret;
+     virtqueue_push(q->tx_vq, q->async_tx.elem, 0);
+     virtio_notify(vdev, q->tx_vq);
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
+     q->async_tx.elem = NULL;
+     virtio_queue_set_notification(q->tx_vq, 1);
+-    virtio_net_flush_tx(q);
++    ret = virtio_net_flush_tx(q);
++    if (q->tx_bh && ret >= n->tx_burst) {
++        /*
++         * the flush has been stopped by tx_burst
++         * we will not receive notification for the
++         * remainining part, so re-schedule
++         */
++        virtio_queue_set_notification(q->tx_vq, 0);
++        qemu_bh_schedule(q->tx_bh);
++        q->tx_waiting = 1;
++    }
+ }
+ /* TX */
+--
+.7.4

-New patch
+[PULL 02/26] virtio-net: fix TX timer with tx_burst
+From: Laurent Vivier <lvivier@redhat.com>
+When virtio_net_flush_tx() reaches the tx_burst value all
+the queue is not flushed and nothing restart the timer.
+Fix that by doing for TX timer as we do for bottom half TX:
+rearming the timer if we find any packet to send during the
+virtio_net_flush_tx() call.
+Fixes: e3f30488e5f8 ("virtio-net: Limit number of packets sent per TX flush")
+Cc: alex.williamson@redhat.com
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/net/virtio-net.c | 50 +++++++++++++++++++++++++++++++++++++++++---------
+file changed, 41 insertions(+), 9 deletions(-)
+diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/net/virtio-net.c
++++ b/hw/net/virtio-net.c
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
+     virtio_queue_set_notification(q->tx_vq, 1);
+     ret = virtio_net_flush_tx(q);
+-    if (q->tx_bh && ret >= n->tx_burst) {
++    if (ret >= n->tx_burst) {
+         /*
+          * the flush has been stopped by tx_burst
+          * we will not receive notification for the
+          * remainining part, so re-schedule
+          */
+         virtio_queue_set_notification(q->tx_vq, 0);
+-        qemu_bh_schedule(q->tx_bh);
++        if (q->tx_bh) {
++            qemu_bh_schedule(q->tx_bh);
++        } else {
++            timer_mod(q->tx_timer,
++                      qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
++        }
+         q->tx_waiting = 1;
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ drop:
+     return num_packets;
+ }
++static void virtio_net_tx_timer(void *opaque);
++
+ static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
+ {
+     VirtIONet *n = VIRTIO_NET(vdev);
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
+     }
+     if (q->tx_waiting) {
+-        virtio_queue_set_notification(vq, 1);
++        /* We already have queued packets, immediately flush */
+         timer_del(q->tx_timer);
+-        q->tx_waiting = 0;
+-        if (virtio_net_flush_tx(q) == -EINVAL) {
+-            return;
+-        }
++        virtio_net_tx_timer(q);
+     } else {
++        /* re-arm timer to flush it (and more) on next tick */
+         timer_mod(q->tx_timer,
+-                       qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
++                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
+         q->tx_waiting = 1;
+         virtio_queue_set_notification(vq, 0);
+     }
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_timer(void *opaque)
+     VirtIONetQueue *q = opaque;
+     VirtIONet *n = q->n;
+     VirtIODevice *vdev = VIRTIO_DEVICE(n);
++    int ret;
++
+     /* This happens when device was stopped but BH wasn't. */
+     if (!vdev->vm_running) {
+         /* Make sure tx waiting is set, so we'll run when restarted. */
+@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_timer(void *opaque)
+         return;
+     }
++    ret = virtio_net_flush_tx(q);
++    if (ret == -EBUSY || ret == -EINVAL) {
++        return;
++    }
++    /*
++     * If we flush a full burst of packets, assume there are
++     * more coming and immediately rearm
++     */
++    if (ret >= n->tx_burst) {
++        q->tx_waiting = 1;
++        timer_mod(q->tx_timer,
++                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
++        return;
++    }
++    /*
++     * If less than a full burst, re-enable notification and flush
++     * anything that may have come in while we weren't looking.  If
++     * we find something, assume the guest is still active and rearm
++     */
+     virtio_queue_set_notification(q->tx_vq, 1);
+-    virtio_net_flush_tx(q);
++    ret = virtio_net_flush_tx(q);
++    if (ret > 0) {
++        virtio_queue_set_notification(q->tx_vq, 0);
++        q->tx_waiting = 1;
++        timer_mod(q->tx_timer,
++                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
++    }
+ }
+ static void virtio_net_tx_bh(void *opaque)
+--
+.7.4

-New patch
+[PULL 03/26] vdpa: Delete duplicated vdpa_feature_bits entry
+From: Eugenio Pérez <eperezma@redhat.com>
+This entry was duplicated on referenced commit. Removing it.
+Fixes: 402378407dbd ("vhost-vdpa: multiqueue support")
+Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
+Acked-by: Jason Wang <jasowang@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/vhost-vdpa.c | 1 -
+file changed, 1 deletion(-)
+diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/vhost-vdpa.c
++++ b/net/vhost-vdpa.c
+@@ -XXX,XX +XXX,XX @@ const int vdpa_feature_bits[] = {
+     VIRTIO_NET_F_CTRL_RX,
+     VIRTIO_NET_F_CTRL_RX_EXTRA,
+     VIRTIO_NET_F_CTRL_VLAN,
+-    VIRTIO_NET_F_GUEST_ANNOUNCE,
+     VIRTIO_NET_F_CTRL_MAC_ADDR,
+     VIRTIO_NET_F_RSS,
+     VIRTIO_NET_F_MQ,
+--
+.7.4

-New patch
+[PULL 04/26] vdpa: Remove shadow CVQ command check
+From: Eugenio Pérez <eperezma@redhat.com>
+The guest will see undefined behavior if it issue not negotiate
+commands, bit it is expected somehow.
+Simplify code deleting this check.
+Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
+Acked-by: Jason Wang <jasowang@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/vhost-vdpa.c | 48 ------------------------------------------------
+file changed, 48 deletions(-)
+diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/vhost-vdpa.c
++++ b/net/vhost-vdpa.c
+@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_vhost_vdpa_cvq_info = {
+ };
+ /**
+- * Do not forward commands not supported by SVQ. Otherwise, the device could
+- * accept it and qemu would not know how to update the device model.
+- */
+-static bool vhost_vdpa_net_cvq_validate_cmd(const void *out_buf, size_t len)
+-{
+-    struct virtio_net_ctrl_hdr ctrl;
+-
+-    if (unlikely(len < sizeof(ctrl))) {
+-        qemu_log_mask(LOG_GUEST_ERROR,
+-                      "%s: invalid legnth of out buffer %zu\n", __func__, len);
+-        return false;
+-    }
+-
+-    memcpy(&ctrl, out_buf, sizeof(ctrl));
+-    switch (ctrl.class) {
+-    case VIRTIO_NET_CTRL_MAC:
+-        switch (ctrl.cmd) {
+-        case VIRTIO_NET_CTRL_MAC_ADDR_SET:
+-            return true;
+-        default:
+-            qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid mac cmd %u\n",
+-                          __func__, ctrl.cmd);
+-        };
+-        break;
+-    case VIRTIO_NET_CTRL_MQ:
+-        switch (ctrl.cmd) {
+-        case VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET:
+-            return true;
+-        default:
+-            qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid mq cmd %u\n",
+-                          __func__, ctrl.cmd);
+-        };
+-        break;
+-    default:
+-        qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid control class %u\n",
+-                      __func__, ctrl.class);
+-    };
+-
+-    return false;
+-}
+-
+-/**
+  * Validate and copy control virtqueue commands.
+  *
+  * Following QEMU guidelines, we offer a copy of the buffers to the device to
+@@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_net_handle_ctrl_avail(VhostShadowVirtqueue *svq,
+         .iov_len = sizeof(status),
+     };
+     ssize_t dev_written = -EINVAL;
+-    bool ok;
+     out.iov_len = iov_to_buf(elem->out_sg, elem->out_num, 0,
+                              s->cvq_cmd_out_buffer,
+                              vhost_vdpa_net_cvq_cmd_len());
+-    ok = vhost_vdpa_net_cvq_validate_cmd(s->cvq_cmd_out_buffer, out.iov_len);
+-    if (unlikely(!ok)) {
+-        goto out;
+-    }
+-
+     dev_written = vhost_vdpa_net_cvq_add(s, out.iov_len, sizeof(status));
+     if (unlikely(dev_written < 0)) {
+         goto out;
+--
+.7.4

-[Qemu-devel] [PULL 5/6] qemu-doc: Get rid of "vlan=X" example in the documentation
+[PULL 05/26] vhost-vdpa: allow passing opened vhostfd to vhost-vdpa
-From: Thomas Huth <thuth@redhat.com>
+From: Si-Wei Liu <si-wei.liu@oracle.com>
-The vlan concept is marked as deprecated, so we should not use
+Similar to other vhost backends, vhostfd can be passed to vhost-vdpa
-this for examples in the documentation anymore.
+backend as another parameter to instantiate vhost-vdpa net client.
 This would benefit the use case where only open file descriptors, as
 opposed to raw vhost-vdpa device paths, are accessible from the QEMU
 process.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
+(qemu) netdev_add type=vhost-vdpa,vhostfd=61,id=vhost-vdpa1
 Signed-off-by: Si-Wei Liu <si-wei.liu@oracle.com>
 Acked-by: Eugenio Pérez <eperezma@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- qemu-options.hx | 4 ++--
+ net/vhost-vdpa.c | 25 ++++++++++++++++++++-----
-file changed, 2 insertions(+), 2 deletions(-)
+ qapi/net.json    |  3 +++
  qemu-options.hx  |  6 ++++--
 files changed, 27 insertions(+), 7 deletions(-)
+diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/vhost-vdpa.c
++++ b/net/vhost-vdpa.c
+@@ -XXX,XX +XXX,XX @@ int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
+     assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA);
+     opts = &netdev->u.vhost_vdpa;
+-    if (!opts->vhostdev) {
+-        error_setg(errp, "vdpa character device not specified with vhostdev");
++    if (!opts->has_vhostdev && !opts->has_vhostfd) {
++        error_setg(errp,
++                   "vhost-vdpa: neither vhostdev= nor vhostfd= was specified");
+         return -1;
+     }
+-    vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
+-    if (vdpa_device_fd == -1) {
+-        return -errno;
++    if (opts->has_vhostdev && opts->has_vhostfd) {
++        error_setg(errp,
++                   "vhost-vdpa: vhostdev= and vhostfd= are mutually exclusive");
++        return -1;
++    }
++
++    if (opts->has_vhostdev) {
++        vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
++        if (vdpa_device_fd == -1) {
++            return -errno;
++        }
++    } else if (opts->has_vhostfd) {
++        vdpa_device_fd = monitor_fd_param(monitor_cur(), opts->vhostfd, errp);
++        if (vdpa_device_fd == -1) {
++            error_prepend(errp, "vhost-vdpa: unable to parse vhostfd: ");
++            return -1;
++        }
+     }
+     r = vhost_vdpa_get_features(vdpa_device_fd, &features, errp);
+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 @@
+ # @vhostdev: path of vhost-vdpa device
+ #            (default:'/dev/vhost-vdpa-0')
+ #
++# @vhostfd: file descriptor of an already opened vhost vdpa device
++#
+ # @queues: number of queues to be created for multiqueue vhost-vdpa
+ #          (default: 1)
+ #
+@@ -XXX,XX +XXX,XX @@
+ { 'struct': 'NetdevVhostVDPAOptions',
+   'data': {
+     '*vhostdev':     'str',
++    '*vhostfd':      'str',
+     '*queues':       'int',
+     '*x-svq':        {'type': 'bool', 'features' : [ 'unstable'] } } }
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
-@@ -XXX,XX +XXX,XX @@ qemu-system-i386 linux.img -net nic -net tap
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
- #launch a QEMU instance with two NICs, each one connected
+     "                configure a vhost-user network, backed by a chardev 'dev'\n"
- #to a TAP device
+ #endif
- qemu-system-i386 linux.img \
+ #ifdef __linux__
--                 -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \
+-    "-netdev vhost-vdpa,id=str,vhostdev=/path/to/dev\n"
--                 -net nic,vlan=1 -net tap,vlan=1,ifname=tap1
++    "-netdev vhost-vdpa,id=str[,vhostdev=/path/to/dev][,vhostfd=h]\n"
-+        -netdev tap,id=nd0,ifname=tap0 -device e1000,netdev=nd0 \
+     "                configure a vhost-vdpa network,Establish a vhost-vdpa netdev\n"
-+        -netdev tap,id=nd1,ifname=tap1 -device rtl8139,netdev=nd1
++    "                use 'vhostdev=/path/to/dev' to open a vhost vdpa device\n"
- @end example
++    "                use 'vhostfd=h' to connect to an already opened vhost vdpa device\n"
+ #endif
- @example
+ #ifdef CONFIG_VMNET
      "-netdev vmnet-host,id=str[,isolated=on|off][,net-uuid=uuid]\n"
@@ -XXX,XX +XXX,XX @@ SRST
               -netdev type=vhost-user,id=net0,chardev=chr0 \
               -device virtio-net-pci,netdev=net0
 -``-netdev vhost-vdpa,vhostdev=/path/to/dev``
 +``-netdev vhost-vdpa[,vhostdev=/path/to/dev][,vhostfd=h]``
      Establish a vhost-vdpa netdev.
      vDPA device is a device that uses a datapath which complies with
 --
 .7.4

-New patch
+[PULL 06/26] net: improve error message for missing netdev backend
+From: Daniel P. Berrangé <berrange@redhat.com>
+The current message when using '-net user...' with SLIRP disabled at
+compile time is:
+  qemu-system-x86_64: -net user: Parameter 'type' expects a net backend type (maybe it is not compiled into this binary)
+An observation is that we're using the 'netdev->type' field here which
+is an enum value, produced after QAPI has converted from its string
+form.
+IOW, at this point in the code, we know that the user's specified
+type name was a valid network backend. The only possible scenario that
+can make the backend init function be NULL, is if support for that
+backend was disabled at build time. Given this, we don't need to caveat
+our error message with a 'maybe' hint, we can be totally explicit.
+The use of QERR_INVALID_PARAMETER_VALUE doesn't really lend itself to
+user friendly error message text. Since this is not used to set a
+specific QAPI error class, we can simply stop using this pre-formatted
+error text and provide something better.
+Thus the new message is:
+  qemu-system-x86_64: -net user: network backend 'user' is not compiled into this binary
+The case of passing 'hubport' for -net is also given a message reminding
+people they should have used -netdev/-nic instead, as this backend type
+is only valid for the modern syntax.
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
+Reviewed-by: Thomas Huth <thuth@redhat.com>
+Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/net.c | 18 +++++++++++-------
+file changed, 11 insertions(+), 7 deletions(-)
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/net.c
++++ b/net/net.c
+@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
+     if (is_netdev) {
+         if (netdev->type == NET_CLIENT_DRIVER_NIC ||
+             !net_client_init_fun[netdev->type]) {
+-            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
+-                       "a netdev backend type");
++            error_setg(errp, "network backend '%s' is not compiled into this binary",
++                       NetClientDriver_str(netdev->type));
+             return -1;
+         }
+     } else {
+         if (netdev->type == NET_CLIENT_DRIVER_NONE) {
+             return 0; /* nothing to do */
+         }
+-        if (netdev->type == NET_CLIENT_DRIVER_HUBPORT ||
+-            !net_client_init_fun[netdev->type]) {
+-            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
+-                       "a net backend type (maybe it is not compiled "
+-                       "into this binary)");
++        if (netdev->type == NET_CLIENT_DRIVER_HUBPORT) {
++            error_setg(errp, "network backend '%s' is only supported with -netdev/-nic",
++                       NetClientDriver_str(netdev->type));
++            return -1;
++        }
++
++        if (!net_client_init_fun[netdev->type]) {
++            error_setg(errp, "network backend '%s' is not compiled into this binary",
++                       NetClientDriver_str(netdev->type));
+             return -1;
+         }
+--
+.7.4

-[Qemu-devel] [PULL 6/6] MAINTAINERS: update Dmitry Fleytman email
+[PULL 07/26] vhost: allocate event_idx fields on vring
-From: Philippe Mathieu-Daudé <f4bug@amsat.org>
+From: Eugenio Pérez <eperezma@redhat.com>
-gently asked by his automatic reply :)
+There was not enough room to accomodate them.
-Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- MAINTAINERS | 8 ++++----
+ hw/virtio/vhost-shadow-virtqueue.c | 8 ++++----
 file changed, 4 insertions(+), 4 deletions(-)
-diff --git a/MAINTAINERS b/MAINTAINERS
+diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c
 index XXXXXXX..XXXXXXX 100644
---- a/MAINTAINERS
+--- a/hw/virtio/vhost-shadow-virtqueue.c
-+++ b/MAINTAINERS
++++ b/hw/virtio/vhost-shadow-virtqueue.c
-@@ -XXX,XX +XXX,XX @@ F: hw/scsi/mfi.h
+@@ -XXX,XX +XXX,XX @@ void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq,
- F: tests/megasas-test.c
+ size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq)
+ {
- Network packet abstractions
+     size_t desc_size = sizeof(vring_desc_t) * svq->vring.num;
--M: Dmitry Fleytman <dmitry@daynix.com>
+-    size_t avail_size = offsetof(vring_avail_t, ring) +
-+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
+-                                             sizeof(uint16_t) * svq->vring.num;
- S: Maintained
++    size_t avail_size = offsetof(vring_avail_t, ring[svq->vring.num]) +
- F: include/net/eth.h
++                                                              sizeof(uint16_t);
- F: net/eth.c
-@@ -XXX,XX +XXX,XX @@ F: hw/net/net_rx_pkt*
+     return ROUND_UP(desc_size + avail_size, qemu_real_host_page_size());
- F: hw/net/net_tx_pkt*
+ }
- Vmware
+ size_t vhost_svq_device_area_size(const VhostShadowVirtqueue *svq)
--M: Dmitry Fleytman <dmitry@daynix.com>
+ {
-+M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
+-    size_t used_size = offsetof(vring_used_t, ring) +
- S: Maintained
+-                                    sizeof(vring_used_elem_t) * svq->vring.num;
- F: hw/net/vmxnet*
++    size_t used_size = offsetof(vring_used_t, ring[svq->vring.num]) +
- F: hw/scsi/vmw_pvscsi*
++                                                              sizeof(uint16_t);
-@@ -XXX,XX +XXX,XX @@ F: hw/mem/nvdimm.c
+     return ROUND_UP(used_size, qemu_real_host_page_size());
- F: include/hw/mem/nvdimm.h
+ }
  e1000x
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: hw/net/e1000x*
  e1000e
 -M: Dmitry Fleytman <dmitry@daynix.com>
 +M: Dmitry Fleytman <dmitry.fleytman@gmail.com>
  S: Maintained
  F: hw/net/e1000e*
 --
 .7.4

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

-New patch
+[PULL 09/26] vhost: use avail event idx on vhost_svq_kick
+From: Eugenio Pérez <eperezma@redhat.com>
+So SVQ code knows if an event is needed.
+The code is not reachable at the moment.
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/virtio/vhost-shadow-virtqueue.c | 12 +++++++++++-
+file changed, 11 insertions(+), 1 deletion(-)
+diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/virtio/vhost-shadow-virtqueue.c
++++ b/hw/virtio/vhost-shadow-virtqueue.c
+@@ -XXX,XX +XXX,XX @@ static bool vhost_svq_add_split(VhostShadowVirtqueue *svq,
+ static void vhost_svq_kick(VhostShadowVirtqueue *svq)
+ {
++    bool needs_kick;
++
+     /*
+      * We need to expose the available array entries before checking the used
+      * flags
+      */
+     smp_mb();
+-    if (svq->vring.used->flags & VRING_USED_F_NO_NOTIFY) {
++
++    if (virtio_vdev_has_feature(svq->vdev, VIRTIO_RING_F_EVENT_IDX)) {
++        uint16_t avail_event = *(uint16_t *)(&svq->vring.used->ring[svq->vring.num]);
++        needs_kick = vring_need_event(avail_event, svq->shadow_avail_idx, svq->shadow_avail_idx - 1);
++    } else {
++        needs_kick = !(svq->vring.used->flags & VRING_USED_F_NO_NOTIFY);
++    }
++
++    if (!needs_kick) {
+         return;
+     }
+--
+.7.4

-New patch
+[PULL 10/26] vhost: Accept event idx flag
+From: Eugenio Pérez <eperezma@redhat.com>
+Enabling all the code path created before.
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ hw/virtio/vhost-shadow-virtqueue.c | 1 +
+file changed, 1 insertion(+)
+diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/virtio/vhost-shadow-virtqueue.c
++++ b/hw/virtio/vhost-shadow-virtqueue.c
+@@ -XXX,XX +XXX,XX @@ bool vhost_svq_valid_features(uint64_t features, Error **errp)
+          ++b) {
+         switch (b) {
+         case VIRTIO_F_ANY_LAYOUT:
++        case VIRTIO_RING_F_EVENT_IDX:
+             continue;
+         case VIRTIO_F_ACCESS_PLATFORM:
+--
+.7.4

-New patch
+[PULL 11/26] net: introduce convert_host_port()
+From: Laurent Vivier <lvivier@redhat.com>
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/qemu/sockets.h |  2 ++
+ net/net.c              | 62 ++++++++++++++++++++++++++------------------------
+files changed, 34 insertions(+), 30 deletions(-)
+diff --git a/include/qemu/sockets.h b/include/qemu/sockets.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/qemu/sockets.h
++++ b/include/qemu/sockets.h
+@@ -XXX,XX +XXX,XX @@ void socket_listen_cleanup(int fd, Error **errp);
+ int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp);
+ /* Old, ipv4 only bits.  Don't use for new code. */
++int convert_host_port(struct sockaddr_in *saddr, const char *host,
++                      const char *port, Error **errp);
+ int parse_host_port(struct sockaddr_in *saddr, const char *str,
+                     Error **errp);
+ int socket_init(void);
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/net.c
++++ b/net/net.c
+@@ -XXX,XX +XXX,XX @@ static QTAILQ_HEAD(, NetClientState) net_clients;
+ /***********************************************************/
+ /* network device redirectors */
+-int parse_host_port(struct sockaddr_in *saddr, const char *str,
+-                    Error **errp)
++int convert_host_port(struct sockaddr_in *saddr, const char *host,
++                      const char *port, Error **errp)
+ {
+-    gchar **substrings;
+     struct hostent *he;
+-    const char *addr, *p, *r;
+-    int port, ret = 0;
++    const char *r;
++    long p;
+     memset(saddr, 0, sizeof(*saddr));
+-    substrings = g_strsplit(str, ":", 2);
+-    if (!substrings || !substrings[0] || !substrings[1]) {
+-        error_setg(errp, "host address '%s' doesn't contain ':' "
+-                   "separating host from port", str);
+-        ret = -1;
+-        goto out;
+-    }
+-
+-    addr = substrings[0];
+-    p = substrings[1];
+-
+     saddr->sin_family = AF_INET;
+-    if (addr[0] == '\0') {
++    if (host[0] == '\0') {
+         saddr->sin_addr.s_addr = 0;
+     } else {
+-        if (qemu_isdigit(addr[0])) {
+-            if (!inet_aton(addr, &saddr->sin_addr)) {
++        if (qemu_isdigit(host[0])) {
++            if (!inet_aton(host, &saddr->sin_addr)) {
+                 error_setg(errp, "host address '%s' is not a valid "
+-                           "IPv4 address", addr);
+-                ret = -1;
+-                goto out;
++                           "IPv4 address", host);
++                return -1;
+             }
+         } else {
+-            he = gethostbyname(addr);
++            he = gethostbyname(host);
+             if (he == NULL) {
+-                error_setg(errp, "can't resolve host address '%s'", addr);
+-                ret = -1;
+-                goto out;
++                error_setg(errp, "can't resolve host address '%s'", host);
++                return -1;
+             }
+             saddr->sin_addr = *(struct in_addr *)he->h_addr;
+         }
+     }
+-    port = strtol(p, (char **)&r, 0);
+-    if (r == p) {
+-        error_setg(errp, "port number '%s' is invalid", p);
++    if (qemu_strtol(port, &r, 0, &p) != 0) {
++        error_setg(errp, "port number '%s' is invalid", port);
++        return -1;
++    }
++    saddr->sin_port = htons(p);
++    return 0;
++}
++
++int parse_host_port(struct sockaddr_in *saddr, const char *str,
++                    Error **errp)
++{
++    gchar **substrings;
++    int ret;
++
++    substrings = g_strsplit(str, ":", 2);
++    if (!substrings || !substrings[0] || !substrings[1]) {
++        error_setg(errp, "host address '%s' doesn't contain ':' "
++                   "separating host from port", str);
+         ret = -1;
+         goto out;
+     }
+-    saddr->sin_port = htons(port);
++
++    ret = convert_host_port(saddr, substrings[0], substrings[1], errp);
+ out:
+     g_strfreev(substrings);
+--
+.7.4

-New patch
+[PULL 12/26] net: remove the @errp argument of net_client_inits()
+From: Laurent Vivier <lvivier@redhat.com>
+The only caller passes &error_fatal, so use this directly in the function.
+It's what we do for -blockdev, -device, and -object.
+Suggested-by: Markus Armbruster <armbru@redhat.com>
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/net/net.h |  2 +-
+ net/net.c         | 20 +++++++-------------
+ softmmu/vl.c      |  2 +-
+files changed, 9 insertions(+), 15 deletions(-)
+diff --git a/include/net/net.h b/include/net/net.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/net/net.h
++++ b/include/net/net.h
+@@ -XXX,XX +XXX,XX @@ extern const char *host_net_devices[];
+ /* from net.c */
+ int net_client_parse(QemuOptsList *opts_list, const char *str);
+ void show_netdevs(void);
+-int net_init_clients(Error **errp);
++void net_init_clients(void);
+ void net_check_clients(void);
+ void net_cleanup(void);
+ void hmp_host_net_add(Monitor *mon, const QDict *qdict);
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/net.c
++++ b/net/net.c
+@@ -XXX,XX +XXX,XX @@ out:
+     return ret;
+ }
+-int net_init_clients(Error **errp)
++void net_init_clients(void)
+ {
+     net_change_state_entry =
+         qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
+     QTAILQ_INIT(&net_clients);
+-    if (qemu_opts_foreach(qemu_find_opts("netdev"),
+-                          net_init_netdev, NULL, errp)) {
+-        return -1;
+-    }
+-
+-    if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL, errp)) {
+-        return -1;
+-    }
++    qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL,
++                      &error_fatal);
+-    if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL, errp)) {
+-        return -1;
+-    }
++    qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL,
++                      &error_fatal);
+-    return 0;
++    qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL,
++                      &error_fatal);
+ }
+ int net_client_parse(QemuOptsList *opts_list, const char *optarg)
+diff --git a/softmmu/vl.c b/softmmu/vl.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/vl.c
++++ b/softmmu/vl.c
+@@ -XXX,XX +XXX,XX @@ static void qemu_create_late_backends(void)
+         qtest_server_init(qtest_chrdev, qtest_log, &error_fatal);
+     }
+-    net_init_clients(&error_fatal);
++    net_init_clients();
+     object_option_foreach_add(object_create_late);
+--
+.7.4

-New patch
+[PULL 13/26] net: simplify net_client_parse() error management
+From: Laurent Vivier <lvivier@redhat.com>
+All net_client_parse() callers exit in case of error.
+Move exit(1) to net_client_parse() and remove error checking from
+the callers.
+Suggested-by: Markus Armbruster <armbru@redhat.com>
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/net/net.h |  2 +-
+ net/net.c         |  6 ++----
+ softmmu/vl.c      | 12 +++---------
+files changed, 6 insertions(+), 14 deletions(-)
+diff --git a/include/net/net.h b/include/net/net.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/net/net.h
++++ b/include/net/net.h
+@@ -XXX,XX +XXX,XX @@ extern NICInfo nd_table[MAX_NICS];
+ extern const char *host_net_devices[];
+ /* from net.c */
+-int net_client_parse(QemuOptsList *opts_list, const char *str);
++void net_client_parse(QemuOptsList *opts_list, const char *str);
+ void show_netdevs(void);
+ void net_init_clients(void);
+ void net_check_clients(void);
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/net.c
++++ b/net/net.c
+@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
+                       &error_fatal);
+ }
+-int net_client_parse(QemuOptsList *opts_list, const char *optarg)
++void net_client_parse(QemuOptsList *opts_list, const char *optarg)
+ {
+     if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
+-        return -1;
++        exit(1);
+     }
+-
+-    return 0;
+ }
+ /* From FreeBSD */
+diff --git a/softmmu/vl.c b/softmmu/vl.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/vl.c
++++ b/softmmu/vl.c
+@@ -XXX,XX +XXX,XX @@ void qemu_init(int argc, char **argv)
+                 break;
+             case QEMU_OPTION_netdev:
+                 default_net = 0;
+-                if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
+-                    exit(1);
+-                }
++                net_client_parse(qemu_find_opts("netdev"), optarg);
+                 break;
+             case QEMU_OPTION_nic:
+                 default_net = 0;
+-                if (net_client_parse(qemu_find_opts("nic"), optarg) == -1) {
+-                    exit(1);
+-                }
++                net_client_parse(qemu_find_opts("nic"), optarg);
+                 break;
+             case QEMU_OPTION_net:
+                 default_net = 0;
+-                if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
+-                    exit(1);
+-                }
++                net_client_parse(qemu_find_opts("net"), optarg);
+                 break;
+ #ifdef CONFIG_LIBISCSI
+             case QEMU_OPTION_iscsi:
+--
+.7.4

-New patch
+[PULL 14/26] qapi: net: introduce a way to bypass qemu_opts_parse_noisily()
+From: Laurent Vivier <lvivier@redhat.com>
+As qemu_opts_parse_noisily() flattens the QAPI structures ("type" field
+of Netdev structure can collides with "type" field of SocketAddress),
+we introduce a way to bypass qemu_opts_parse_noisily() and use directly
+visit_type_Netdev() to parse the backend parameters.
+More details from Markus:
+qemu_init() passes the argument of -netdev, -nic, and -net to
+net_client_parse().
+net_client_parse() parses with qemu_opts_parse_noisily(), passing
+QemuOptsList qemu_netdev_opts for -netdev, qemu_nic_opts for -nic, and
+qemu_net_opts for -net.  Their desc[] are all empty, which means any
+keys are accepted.  The result of the parse (a QemuOpts) is stored in
+the QemuOptsList.
+Note that QemuOpts is flat by design.  In some places, we layer non-flat
+on top using dotted keys convention, but not here.
+net_init_clients() iterates over the stored QemuOpts, and passes them to
+net_init_netdev(), net_param_nic(), or net_init_client(), respectively.
+These functions pass the QemuOpts to net_client_init().  They also do
+other things with the QemuOpts, which we can ignore here.
+net_client_init() uses the opts visitor to convert the (flat) QemOpts to
+a (non-flat) QAPI object Netdev.  Netdev is also the argument of QMP
+command netdev_add.
+The opts visitor was an early attempt to support QAPI in
+(QemuOpts-based) CLI.  It restricts QAPI types to a certain shape; see
+commit eb7ee2cbeb "qapi: introduce OptsVisitor".
+A more modern way to support QAPI is qobject_input_visitor_new_str().
+It uses keyval_parse() instead of QemuOpts for KEY=VALUE,... syntax, and
+it also supports JSON syntax.  The former isn't quite as expressive as
+JSON, but it's a lot closer than QemuOpts + opts visitor.
+This commit paves the way to use of the modern way instead.
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/net/net.h |  2 ++
+ net/net.c         | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ softmmu/vl.c      |  6 +++++-
+files changed, 64 insertions(+), 1 deletion(-)
+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 @@ extern NICInfo nd_table[MAX_NICS];
+ extern const char *host_net_devices[];
+ /* from net.c */
++bool netdev_is_modern(const char *optarg);
++void netdev_parse_modern(const char *optarg);
+ void net_client_parse(QemuOptsList *opts_list, const char *str);
+ void show_netdevs(void);
+ void net_init_clients(void);
+diff --git a/net/net.c b/net/net.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/net.c
++++ b/net/net.c
+@@ -XXX,XX +XXX,XX @@
+ #include "net/colo-compare.h"
+ #include "net/filter.h"
+ #include "qapi/string-output-visitor.h"
++#include "qapi/qobject-input-visitor.h"
+ /* Net bridge is currently not supported for W32. */
+ #if !defined(_WIN32)
+@@ -XXX,XX +XXX,XX @@
+ static VMChangeStateEntry *net_change_state_entry;
+ static QTAILQ_HEAD(, NetClientState) net_clients;
++typedef struct NetdevQueueEntry {
++    Netdev *nd;
++    Location loc;
++    QSIMPLEQ_ENTRY(NetdevQueueEntry) entry;
++} NetdevQueueEntry;
++
++typedef QSIMPLEQ_HEAD(, NetdevQueueEntry) NetdevQueue;
++
++static NetdevQueue nd_queue = QSIMPLEQ_HEAD_INITIALIZER(nd_queue);
++
+ /***********************************************************/
+ /* network device redirectors */
+@@ -XXX,XX +XXX,XX @@ out:
+     return ret;
+ }
++static void netdev_init_modern(void)
++{
++    while (!QSIMPLEQ_EMPTY(&nd_queue)) {
++        NetdevQueueEntry *nd = QSIMPLEQ_FIRST(&nd_queue);
++
++        QSIMPLEQ_REMOVE_HEAD(&nd_queue, entry);
++        loc_push_restore(&nd->loc);
++        net_client_init1(nd->nd, true, &error_fatal);
++        loc_pop(&nd->loc);
++        qapi_free_Netdev(nd->nd);
++        g_free(nd);
++    }
++}
++
+ void net_init_clients(void)
+ {
+     net_change_state_entry =
+@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
+     QTAILQ_INIT(&net_clients);
++    netdev_init_modern();
++
+     qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL,
+                       &error_fatal);
+@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
+                       &error_fatal);
+ }
++/*
++ * Does this -netdev argument use modern rather than traditional syntax?
++ * Modern syntax is to be parsed with netdev_parse_modern().
++ * Traditional syntax is to be parsed with net_client_parse().
++ */
++bool netdev_is_modern(const char *optarg)
++{
++    return false;
++}
++
++/*
++ * netdev_parse_modern() uses modern, more expressive syntax than
++ * net_client_parse(), but supports only the -netdev option.
++ * netdev_parse_modern() appends to @nd_queue, whereas net_client_parse()
++ * appends to @qemu_netdev_opts.
++ */
++void netdev_parse_modern(const char *optarg)
++{
++    Visitor *v;
++    NetdevQueueEntry *nd;
++
++    v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
++    nd = g_new(NetdevQueueEntry, 1);
++    visit_type_Netdev(v, NULL, &nd->nd, &error_fatal);
++    visit_free(v);
++    loc_save(&nd->loc);
++
++    QSIMPLEQ_INSERT_TAIL(&nd_queue, nd, entry);
++}
++
+ void net_client_parse(QemuOptsList *opts_list, const char *optarg)
+ {
+     if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
+diff --git a/softmmu/vl.c b/softmmu/vl.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/vl.c
++++ b/softmmu/vl.c
+@@ -XXX,XX +XXX,XX @@ void qemu_init(int argc, char **argv)
+                 break;
+             case QEMU_OPTION_netdev:
+                 default_net = 0;
+-                net_client_parse(qemu_find_opts("netdev"), optarg);
++                if (netdev_is_modern(optarg)) {
++                    netdev_parse_modern(optarg);
++                } else {
++                    net_client_parse(qemu_find_opts("netdev"), optarg);
++                }
+                 break;
+             case QEMU_OPTION_nic:
+                 default_net = 0;
+--
+.7.4

-[Qemu-devel] [PULL 4/6] net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove'
+[PULL 15/26] net: introduce qemu_set_info_str() function
-From: Thomas Huth <thuth@redhat.com>
+From: Laurent Vivier <lvivier@redhat.com>
-It does not make much sense to limit these commands to the legacy 'vlan'
+Embed the setting of info_str in a function.
-concept only, they should work with the modern netdevs, too. So now
-it is possible to use this command with one, two or three parameters.
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
-With one parameter, the command installs a hostfwd rule on the default
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
-"user" network:
+Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
     hostfwd_add tcp:...
 With two parameters, the command installs a hostfwd rule on a netdev
 (that's the new way of using this command):
     hostfwd_add netdev_id tcp:...
 With three parameters, the command installs a rule on a 'vlan' (aka hub):
     hostfwd_add hub_id name tcp:...
 Same applies to the hostfwd_remove command now.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hmp-commands.hx |  4 ++--
+ hw/net/xen_nic.c  |  5 ++---
- net/slirp.c     | 33 +++++++++++++++++++++++----------
+ include/net/net.h |  1 +
-files changed, 25 insertions(+), 12 deletions(-)
+ net/l2tpv3.c      |  3 +--
+ net/net.c         | 17 ++++++++++++-----
-diff --git a/hmp-commands.hx b/hmp-commands.hx
+ net/slirp.c       |  5 ++---
-index XXXXXXX..XXXXXXX 100644
+ net/socket.c      | 33 ++++++++++++++-------------------
---- a/hmp-commands.hx
+ net/tap-win32.c   |  3 +--
-+++ b/hmp-commands.hx
+ net/tap.c         | 13 +++++--------
-@@ -XXX,XX +XXX,XX @@ ETEXI
+ net/vde.c         |  3 +--
-     {
+ net/vhost-user.c  |  3 +--
-         .name       = "hostfwd_add",
+ net/vhost-vdpa.c  |  2 +-
-         .args_type  = "arg1:s,arg2:s?,arg3:s?",
+files changed, 41 insertions(+), 47 deletions(-)
--        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
-+        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
+diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
-         .help       = "redirect TCP or UDP connections from host to guest (requires -net user)",
+index XXXXXXX..XXXXXXX 100644
-         .cmd        = hmp_hostfwd_add,
+--- a/hw/net/xen_nic.c
-     },
++++ b/hw/net/xen_nic.c
-@@ -XXX,XX +XXX,XX @@ ETEXI
+@@ -XXX,XX +XXX,XX @@ static int net_init(struct XenLegacyDevice *xendev)
-     {
+     netdev->nic = qemu_new_nic(&net_xen_info, &netdev->conf,
-         .name       = "hostfwd_remove",
+                                "xen", NULL, netdev);
-         .args_type  = "arg1:s,arg2:s?,arg3:s?",
--        .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport",
+-    snprintf(qemu_get_queue(netdev->nic)->info_str,
-+        .params     = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport",
+-             sizeof(qemu_get_queue(netdev->nic)->info_str),
-         .help       = "remove host-to-guest TCP or UDP redirection",
+-             "nic: xenbus vif macaddr=%s", netdev->mac);
-         .cmd        = hmp_hostfwd_remove,
++    qemu_set_info_str(qemu_get_queue(netdev->nic),
-     },
++                      "nic: xenbus vif macaddr=%s", netdev->mac);
      /* fill info */
      xenstore_write_be_int(&netdev->xendev, "feature-rx-copy", 1);
 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 @@ ssize_t qemu_send_packet_async(NetClientState *nc, const uint8_t *buf,
  void qemu_purge_queued_packets(NetClientState *nc);
  void qemu_flush_queued_packets(NetClientState *nc);
  void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge);
 +void qemu_set_info_str(NetClientState *nc, const char *fmt, ...);
  void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6]);
  bool qemu_has_ufo(NetClientState *nc);
  bool qemu_has_vnet_hdr(NetClientState *nc);
 diff --git a/net/l2tpv3.c b/net/l2tpv3.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/l2tpv3.c
 +++ b/net/l2tpv3.c
@@ -XXX,XX +XXX,XX @@ int net_init_l2tpv3(const Netdev *netdev,
      l2tpv3_read_poll(s, true);
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "l2tpv3: connected");
 +    qemu_set_info_str(&s->nc, "l2tpv3: connected");
      return 0;
  outerr:
      qemu_del_net_client(nc);
 diff --git a/net/net.c b/net/net.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/net.c
 +++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ char *qemu_mac_strdup_printf(const uint8_t *macaddr)
                             macaddr[3], macaddr[4], macaddr[5]);
  }
 +void qemu_set_info_str(NetClientState *nc, const char *fmt, ...)
 +{
 +    va_list ap;
 +
 +    va_start(ap, fmt);
 +    vsnprintf(nc->info_str, sizeof(nc->info_str), fmt, ap);
 +    va_end(ap);
 +}
 +
  void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
  {
 -    snprintf(nc->info_str, sizeof(nc->info_str),
 -             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 -             nc->model,
 -             macaddr[0], macaddr[1], macaddr[2],
 -             macaddr[3], macaddr[4], macaddr[5]);
 +    qemu_set_info_str(nc, "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
 +                      nc->model, macaddr[0], macaddr[1], macaddr[2],
 +                      macaddr[3], macaddr[4], macaddr[5]);
  }
  static int mac_table[256] = {0};
 diff --git a/net/slirp.c b/net/slirp.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/slirp.c
 +++ b/net/slirp.c
-@@ -XXX,XX +XXX,XX @@ error:
+@@ -XXX,XX +XXX,XX @@ static int net_slirp_init(NetClientState *peer, const char *model,
-     return -1;
- }
+     nc = qemu_new_net_client(&net_slirp_info, peer, model, name);
--static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
+-    snprintf(nc->info_str, sizeof(nc->info_str),
--                                const char *stack)
+-             "net=%s,restrict=%s", inet_ntoa(net),
-+static SlirpState *slirp_lookup(Monitor *mon, const char *hub_id,
+-             restricted ? "on" : "off");
-+                                const char *name)
++    qemu_set_info_str(nc, "net=%s,restrict=%s", inet_ntoa(net),
- {
++                      restricted ? "on" : "off");
--
--    if (vlan) {
+     s = DO_UPCAST(SlirpState, nc, nc);
-+    if (name) {
-         NetClientState *nc;
+diff --git a/net/socket.c b/net/socket.c
--        nc = net_hub_find_client_by_name(strtol(vlan, NULL, 0), stack);
+index XXXXXXX..XXXXXXX 100644
--        if (!nc) {
+--- a/net/socket.c
--            monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
++++ b/net/socket.c
--            return NULL;
+@@ -XXX,XX +XXX,XX @@ static void net_socket_send(void *opaque)
-+        if (hub_id) {
+         s->fd = -1;
-+            nc = net_hub_find_client_by_name(strtol(hub_id, NULL, 0), name);
+         net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
-+            if (!nc) {
+         s->nc.link_down = true;
-+                monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n");
+-        memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
-+                return NULL;
++        qemu_set_info_str(&s->nc, "");
-+            }
-+        } else {
+         return;
-+            nc = qemu_find_netdev(name);
+     }
-+            if (!nc) {
+@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
-+                monitor_printf(mon, "unrecognized netdev id '%s'\n", name);
+     /* mcast: save bound address as dst */
-+                return NULL;
+     if (is_connected && mcast != NULL) {
-+            }
+         s->dgram_dst = saddr;
 -        snprintf(nc->info_str, sizeof(nc->info_str),
 -                 "socket: fd=%d (cloned mcast=%s:%d)",
 -                 fd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +        qemu_set_info_str(nc, "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;
          }
-         if (strcmp(nc->model, "user")) {
-             monitor_printf(mon, "invalid device specified\n");
+-        snprintf(nc->info_str, sizeof(nc->info_str),
-@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
+-                 "socket: fd=%d %s", fd, SocketAddressType_str(sa_type));
-     const char *arg2 = qdict_get_try_str(qdict, "arg2");
++        qemu_set_info_str(nc, "socket: fd=%d %s", fd,
-     const char *arg3 = qdict_get_try_str(qdict, "arg3");
++                          SocketAddressType_str(sa_type));
+     }
--    if (arg2) {
-+    if (arg3) {
+     return s;
-         s = slirp_lookup(mon, arg1, arg2);
+@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
-         src_str = arg3;
-+    } else if (arg2) {
+     nc = qemu_new_net_client(&net_socket_info, peer, model, name);
-+        s = slirp_lookup(mon, NULL, arg1);
-+        src_str = arg2;
+-    snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
 +    qemu_set_info_str(nc, "socket: fd=%d", fd);
      s = DO_UPCAST(NetSocketState, nc, nc);
@@ -XXX,XX +XXX,XX @@ static void net_socket_accept(void *opaque)
      s->fd = fd;
      s->nc.link_down = false;
      net_socket_connect(s);
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "socket: connection from %s:%d",
 -             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +    qemu_set_info_str(&s->nc, "socket: connection from %s:%d",
 +                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
  }
  static int net_socket_listen_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_socket_connect_init(NetClientState *peer,
          return -1;
      }
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "socket: connect to %s:%d",
 -             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +    qemu_set_info_str(&s->nc, "socket: connect to %s:%d",
 +                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static int net_socket_mcast_init(NetClientState *peer,
      s->dgram_dst = saddr;
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "socket: mcast=%s:%d",
 -             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +    qemu_set_info_str(&s->nc, "socket: mcast=%s:%d",
 +                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static int net_socket_udp_init(NetClientState *peer,
      s->dgram_dst = raddr;
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "socket: udp=%s:%d",
 -             inet_ntoa(raddr.sin_addr), ntohs(raddr.sin_port));
 +    qemu_set_info_str(&s->nc, "socket: udp=%s:%d", inet_ntoa(raddr.sin_addr),
 +                      ntohs(raddr.sin_port));
      return 0;
  }
 diff --git a/net/tap-win32.c b/net/tap-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/tap-win32.c
 +++ b/net/tap-win32.c
@@ -XXX,XX +XXX,XX @@ static int tap_win32_init(NetClientState *peer, const char *model,
      s = DO_UPCAST(TAPState, nc, nc);
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
 -             "tap: ifname=%s", ifname);
 +    qemu_set_info_str(&s->nc, "tap: ifname=%s", ifname);
      s->handle = handle;
 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,
      }
      s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
 -    snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", helper,
 -             br);
 +    qemu_set_info_str(&s->nc, "helper=%s,br=%s", helper, br);
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
      }
      if (tap->has_fd || tap->has_fds) {
 -        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "fd=%d", fd);
 +        qemu_set_info_str(&s->nc, "fd=%d", fd);
      } else if (tap->has_helper) {
 -        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s",
 -                 tap->helper);
 +        qemu_set_info_str(&s->nc, "helper=%s", tap->helper);
      } else {
-         s = slirp_lookup(mon, NULL, NULL);
+-        snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-         src_str = arg1;
+-                 "ifname=%s,script=%s,downscript=%s", ifname, script,
-@@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_add(Monitor *mon, const QDict *qdict)
+-                 downscript);
-     const char *arg2 = qdict_get_try_str(qdict, "arg2");
++        qemu_set_info_str(&s->nc, "ifname=%s,script=%s,downscript=%s", ifname,
-     const char *arg3 = qdict_get_try_str(qdict, "arg3");
++                          script, downscript);
--    if (arg2) {
+         if (strcmp(downscript, "no") != 0) {
-+    if (arg3) {
+             snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);
-         s = slirp_lookup(mon, arg1, arg2);
+diff --git a/net/vde.c b/net/vde.c
-         redir_str = arg3;
+index XXXXXXX..XXXXXXX 100644
-+    } else if (arg2) {
+--- a/net/vde.c
-+        s = slirp_lookup(mon, NULL, arg1);
++++ b/net/vde.c
-+        redir_str = arg2;
+@@ -XXX,XX +XXX,XX @@ static int net_vde_init(NetClientState *peer, const char *model,
-     } else {
-         s = slirp_lookup(mon, NULL, NULL);
+     nc = qemu_new_net_client(&net_vde_info, peer, model, name);
-         redir_str = arg1;
 -    snprintf(nc->info_str, sizeof(nc->info_str), "sock=%s,fd=%d",
 -             sock, vde_datafd(vde));
 +    qemu_set_info_str(nc, "sock=%s,fd=%d", sock, vde_datafd(vde));
      s = DO_UPCAST(VDEState, nc, nc);
 diff --git a/net/vhost-user.c b/net/vhost-user.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/vhost-user.c
 +++ b/net/vhost-user.c
@@ -XXX,XX +XXX,XX @@ static int net_vhost_user_init(NetClientState *peer, const char *device,
      user = g_new0(struct VhostUserState, 1);
      for (i = 0; i < queues; i++) {
          nc = qemu_new_net_client(&net_vhost_user_info, peer, device, name);
 -        snprintf(nc->info_str, sizeof(nc->info_str), "vhost-user%d to %s",
 -                 i, chr->label);
 +        qemu_set_info_str(nc, "vhost-user%d to %s", i, chr->label);
          nc->queue_index = i;
          if (!nc0) {
              nc0 = nc;
 diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/vhost-vdpa.c
 +++ b/net/vhost-vdpa.c
@@ -XXX,XX +XXX,XX @@ static NetClientState *net_vhost_vdpa_init(NetClientState *peer,
          nc = qemu_new_net_control_client(&net_vhost_vdpa_cvq_info, peer,
                                           device, name);
      }
 -    snprintf(nc->info_str, sizeof(nc->info_str), TYPE_VHOST_VDPA);
 +    qemu_set_info_str(nc, TYPE_VHOST_VDPA);
      s = DO_UPCAST(VhostVDPAState, nc, nc);
      s->vhost_vdpa.device_fd = vdpa_device_fd;
 --
 .7.4

-[Qemu-devel] [PULL 3/6] net: Allow hubports to connect to other netdevs
+[PULL 16/26] qapi: net: add stream and dgram netdevs
-From: Thomas Huth <thuth@redhat.com>
+From: Laurent Vivier <lvivier@redhat.com>
-QEMU can emulate hubs to connect NICs and netdevs. This is currently
+Copied from socket netdev file and modified to use SocketAddress
-primarily used for the mis-named 'vlan' feature of the networking
+to be able to introduce new features like unix socket.
 subsystem. Now the 'vlan' feature has been marked as deprecated, since
 its name is rather confusing and the users often rather mis-configure
 their network when trying to use it. But while the 'vlan' parameter
 should be removed at one point in time, the basic idea of emulating
 a hub in QEMU is still good: It's useful for bundling up the output of
 multiple NICs into one single l2tp netdev for example.
-Now to be able to use the hubport feature without 'vlan's, there is one
+"udp" and "mcast" are squashed into dgram netdev, multicast is detected
-missing piece: The possibility to connect a hubport to a netdev, too.
+according to the IP address type.
-This patch adds this possibility by introducing a new "netdev=..."
+"listen" and "connect" modes are managed by stream netdev. An optional
-parameter to the hubports.
+parameter "server" defines the mode (off by default)
-To bundle up the output of multiple NICs into one socket netdev, you can
+The two new types need to be parsed the modern way with -netdev, because
-now run QEMU with these parameters for example:
+with the traditional way, the "type" field of netdev structure collides with
 the "type" field of SocketAddress and prevents the correct evaluation of the
 command line option. Moreover the traditional way doesn't allow to use
 the same type (SocketAddress) several times with the -netdev option
 (needed to specify "local" and "remote" addresses).
-qemu-system-ppc64 ... -netdev socket,id=s1,connect=:11122 \
+The previous commit paved the way for parsing the modern way, but
-    -netdev hubport,hubid=1,id=h1,netdev=s1 \
+omitted one detail: how to pick modern vs. traditional, in
-    -netdev hubport,hubid=1,id=h2 -device e1000,netdev=h2 \
+netdev_is_modern().
     -netdev hubport,hubid=1,id=h3 -device virtio-net-pci,netdev=h3
-For using the socket netdev, you have got to start another QEMU as the
+We want to pick based on the value of parameter "type".  But how to
-receiving side first, for example with network dumping enabled:
+extract it from the option argument?
-qemu-system-x86_64 -M isapc -netdev socket,id=s0,listen=:11122 \
+Parsing the option argument, either the modern or the traditional way,
-    -device ne2k_isa,netdev=s0 \
+extracts it for us, but only if parsing succeeds.
     -object filter-dump,id=f1,netdev=s0,file=/tmp/dump.dat
-After the ppc64 guest tried to boot from both NICs, you can see in the
+If parsing fails, there is no good option.  No matter which parser we
-dump file (using Wireshark, for example), that the output of both NICs
+pick, it'll be the wrong one for some arguments, and the error
-(the e1000 and the virtio-net-pci) has been successfully transfered
+reporting will be confusing.
 via the socket netdev in this case.
-Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
+Fortunately, the traditional parser accepts *anything* when called in
-Signed-off-by: Thomas Huth <thuth@redhat.com>
+a certain way.  This maximizes our chance to extract the value of
 "type", and in turn minimizes the risk of confusing error reporting.
 Signed-off-by: Laurent Vivier <lvivier@redhat.com>
 Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Acked-by: Michael S. Tsirkin <mst@redhat.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/hub.c       | 27 +++++++++++++++++++++------
+ hmp-commands.hx |   2 +-
- net/hub.h       |  3 ++-
+ net/clients.h   |   6 +
- net/net.c       |  2 +-
+ net/dgram.c     | 537 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- qapi/net.json   |  4 +++-
+ net/hub.c       |   2 +
- qemu-options.hx |  8 +++++---
+ net/meson.build |   2 +
-files changed, 32 insertions(+), 12 deletions(-)
+ net/net.c       |  30 +++-
  net/stream.c    | 425 ++++++++++++++++++++++++++++++++++++++++++++
  qapi/net.json   |  66 ++++++-
  qemu-options.hx |  12 ++
 files changed, 1078 insertions(+), 4 deletions(-)
  create mode 100644 net/dgram.c
  create mode 100644 net/stream.c
+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 @@ ERST
+     {
+         .name       = "netdev_add",
+         .args_type  = "netdev:O",
+-        .params     = "[user|tap|socket|vde|bridge|hubport|netmap|vhost-user"
++        .params     = "[user|tap|socket|stream|dgram|vde|bridge|hubport|netmap|vhost-user"
+ #ifdef CONFIG_VMNET
+                       "|vmnet-host|vmnet-shared|vmnet-bridged"
+ #endif
+diff --git a/net/clients.h b/net/clients.h
+index XXXXXXX..XXXXXXX 100644
+--- a/net/clients.h
++++ b/net/clients.h
+@@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name,
+ int net_init_socket(const Netdev *netdev, const char *name,
+                     NetClientState *peer, Error **errp);
++int net_init_stream(const Netdev *netdev, const char *name,
++                    NetClientState *peer, Error **errp);
++
++int net_init_dgram(const Netdev *netdev, const char *name,
++                   NetClientState *peer, Error **errp);
++
+ int net_init_tap(const Netdev *netdev, const char *name,
+                  NetClientState *peer, Error **errp);
+diff --git a/net/dgram.c b/net/dgram.c
+new file mode 100644
+index XXXXXXX..XXXXXXX
+--- /dev/null
++++ b/net/dgram.c
+@@ -XXX,XX +XXX,XX @@
++/*
++ * QEMU System Emulator
++ *
++ * Copyright (c) 2003-2008 Fabrice Bellard
++ * Copyright (c) 2022 Red Hat, Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to deal
++ * in the Software without restriction, including without limitation the rights
++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++ * THE SOFTWARE.
++ */
++
++#include "qemu/osdep.h"
++
++#include "net/net.h"
++#include "clients.h"
++#include "monitor/monitor.h"
++#include "qapi/error.h"
++#include "qemu/error-report.h"
++#include "qemu/option.h"
++#include "qemu/sockets.h"
++#include "qemu/iov.h"
++#include "qemu/main-loop.h"
++#include "qemu/cutils.h"
++
++typedef struct NetDgramState {
++    NetClientState nc;
++    int fd;
++    SocketReadState rs;
++    struct sockaddr_in dgram_dst; /* contains destination iff connectionless */
++    bool read_poll;               /* waiting to receive data? */
++    bool write_poll;              /* waiting to transmit data? */
++} NetDgramState;
++
++static void net_dgram_send(void *opaque);
++static void net_dgram_writable(void *opaque);
++
++static void net_dgram_update_fd_handler(NetDgramState *s)
++{
++    qemu_set_fd_handler(s->fd,
++                        s->read_poll ? net_dgram_send : NULL,
++                        s->write_poll ? net_dgram_writable : NULL,
++                        s);
++}
++
++static void net_dgram_read_poll(NetDgramState *s, bool enable)
++{
++    s->read_poll = enable;
++    net_dgram_update_fd_handler(s);
++}
++
++static void net_dgram_write_poll(NetDgramState *s, bool enable)
++{
++    s->write_poll = enable;
++    net_dgram_update_fd_handler(s);
++}
++
++static void net_dgram_writable(void *opaque)
++{
++    NetDgramState *s = opaque;
++
++    net_dgram_write_poll(s, false);
++
++    qemu_flush_queued_packets(&s->nc);
++}
++
++static ssize_t net_dgram_receive(NetClientState *nc,
++                                 const uint8_t *buf, size_t size)
++{
++    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
++    ssize_t ret;
++
++    do {
++        if (s->dgram_dst.sin_family != AF_UNIX) {
++            ret = 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) {
++        net_dgram_write_poll(s, true);
++        return 0;
++    }
++    return ret;
++}
++
++static void net_dgram_send_completed(NetClientState *nc, ssize_t len)
++{
++    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
++
++    if (!s->read_poll) {
++        net_dgram_read_poll(s, true);
++    }
++}
++
++static void net_dgram_rs_finalize(SocketReadState *rs)
++{
++    NetDgramState *s = container_of(rs, NetDgramState, rs);
++
++    if (qemu_send_packet_async(&s->nc, rs->buf,
++                               rs->packet_len,
++                               net_dgram_send_completed) == 0) {
++        net_dgram_read_poll(s, false);
++    }
++}
++
++static void net_dgram_send(void *opaque)
++{
++    NetDgramState *s = opaque;
++    int size;
++
++    size = recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0);
++    if (size < 0) {
++        return;
++    }
++    if (size == 0) {
++        /* end of connection */
++        net_dgram_read_poll(s, false);
++        net_dgram_write_poll(s, false);
++        return;
++    }
++    if (qemu_send_packet_async(&s->nc, s->rs.buf, size,
++                               net_dgram_send_completed) == 0) {
++        net_dgram_read_poll(s, false);
++    }
++}
++
++static int net_dgram_mcast_create(struct sockaddr_in *mcastaddr,
++                                  struct in_addr *localaddr,
++                                  Error **errp)
++{
++    struct ip_mreq imr;
++    int fd;
++    int val, ret;
++#ifdef __OpenBSD__
++    unsigned char loop;
++#else
++    int loop;
++#endif
++
++    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
++        error_setg(errp, "specified mcastaddr %s (0x%08x) "
++                   "does not contain a multicast address",
++                   inet_ntoa(mcastaddr->sin_addr),
++                   (int)ntohl(mcastaddr->sin_addr.s_addr));
++        return -1;
++    }
++
++    fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
++    if (fd < 0) {
++        error_setg_errno(errp, errno, "can't create datagram socket");
++        return -1;
++    }
++
++    /*
++     * Allow multiple sockets to bind the same multicast ip and port by setting
++     * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set
++     * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR
++     * only on posix systems.
++     */
++    val = 1;
++    ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
++    if (ret < 0) {
++        error_setg_errno(errp, errno, "can't set socket option SO_REUSEADDR");
++        goto fail;
++    }
++
++    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
++    if (ret < 0) {
++        error_setg_errno(errp, errno, "can't bind ip=%s to socket",
++                         inet_ntoa(mcastaddr->sin_addr));
++        goto fail;
++    }
++
++    /* Add host to multicast group */
++    imr.imr_multiaddr = mcastaddr->sin_addr;
++    if (localaddr) {
++        imr.imr_interface = *localaddr;
++    } else {
++        imr.imr_interface.s_addr = htonl(INADDR_ANY);
++    }
++
++    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
++                     &imr, sizeof(struct ip_mreq));
++    if (ret < 0) {
++        error_setg_errno(errp, errno,
++                         "can't add socket to multicast group %s",
++                         inet_ntoa(imr.imr_multiaddr));
++        goto fail;
++    }
++
++    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
++    loop = 1;
++    ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
++                     &loop, sizeof(loop));
++    if (ret < 0) {
++        error_setg_errno(errp, errno,
++                         "can't force multicast message to loopback");
++        goto fail;
++    }
++
++    /* If a bind address is given, only send packets from that address */
++    if (localaddr != NULL) {
++        ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
++                         localaddr, sizeof(*localaddr));
++        if (ret < 0) {
++            error_setg_errno(errp, errno,
++                             "can't set the default network send interface");
++            goto fail;
++        }
++    }
++
++    qemu_socket_set_nonblock(fd);
++    return fd;
++fail:
++    if (fd >= 0) {
++        closesocket(fd);
++    }
++    return -1;
++}
++
++static void net_dgram_cleanup(NetClientState *nc)
++{
++    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
++    if (s->fd != -1) {
++        net_dgram_read_poll(s, false);
++        net_dgram_write_poll(s, false);
++        close(s->fd);
++        s->fd = -1;
++    }
++}
++
++static NetClientInfo net_dgram_socket_info = {
++    .type = NET_CLIENT_DRIVER_DGRAM,
++    .size = sizeof(NetDgramState),
++    .receive = net_dgram_receive,
++    .cleanup = net_dgram_cleanup,
++};
++
++static NetDgramState *net_dgram_fd_init(NetClientState *peer,
++                                        const char *model,
++                                        const char *name,
++                                        int fd, int is_fd,
++                                        SocketAddress *mcast,
++                                        Error **errp)
++{
++    struct sockaddr_in saddr;
++    int newfd;
++    NetClientState *nc;
++    NetDgramState *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() by ONLY ONE process: we must "clone" this
++     * dgram socket --jjo
++     */
++
++    if (is_fd && mcast != NULL) {
++            if (convert_host_port(&saddr, mcast->u.inet.host,
++                                  mcast->u.inet.port, errp) < 0) {
++                goto err;
++            }
++            /* must be bound */
++            if (saddr.sin_addr.s_addr == 0) {
++                error_setg(errp, "can't setup multicast destination address");
++                goto err;
++            }
++            /* clone dgram socket */
++            newfd = net_dgram_mcast_create(&saddr, NULL, errp);
++            if (newfd < 0) {
++                goto err;
++            }
++            /* clone newfd to fd, close newfd */
++            dup2(newfd, fd);
++            close(newfd);
++
++    }
++
++    nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
++
++    s = DO_UPCAST(NetDgramState, nc, nc);
++
++    s->fd = fd;
++    net_socket_rs_init(&s->rs, net_dgram_rs_finalize, false);
++    net_dgram_read_poll(s, true);
++
++    /* mcast: save bound address as dst */
++    if (is_fd && mcast != NULL) {
++        s->dgram_dst = saddr;
++        qemu_set_info_str(nc, "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;
++        }
++
++        qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
++    }
++
++    return s;
++
++err:
++    closesocket(fd);
++    return NULL;
++}
++
++static int net_dgram_mcast_init(NetClientState *peer,
++                                const char *model,
++                                const char *name,
++                                SocketAddress *remote,
++                                SocketAddress *local,
++                                Error **errp)
++{
++    NetDgramState *s;
++    int fd, ret;
++    struct sockaddr_in saddr;
++
++    if (remote->type != SOCKET_ADDRESS_TYPE_INET) {
++        error_setg(errp, "multicast only support inet type");
++        return -1;
++    }
++
++    if (convert_host_port(&saddr, remote->u.inet.host, remote->u.inet.port,
++                          errp) < 0) {
++        return -1;
++    }
++
++    if (!local) {
++        fd = net_dgram_mcast_create(&saddr, NULL, errp);
++        if (fd < 0) {
++            return -1;
++        }
++    } else {
++        switch (local->type) {
++        case SOCKET_ADDRESS_TYPE_INET: {
++            struct in_addr localaddr;
++
++            if (inet_aton(local->u.inet.host, &localaddr) == 0) {
++                error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
++                           local->u.inet.host);
++                return -1;
++            }
++
++            fd = net_dgram_mcast_create(&saddr, &localaddr, errp);
++            if (fd < 0) {
++                return -1;
++            }
++            break;
++        }
++        case SOCKET_ADDRESS_TYPE_FD:
++            fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
++            if (fd == -1) {
++                return -1;
++            }
++            ret = qemu_socket_try_set_nonblock(fd);
++            if (ret < 0) {
++                error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
++                                 name, fd);
++                return -1;
++            }
++            break;
++        default:
++            error_setg(errp, "only support inet or fd type for local");
++            return -1;
++        }
++    }
++
++    s = net_dgram_fd_init(peer, model, name, fd,
++                          local->type == SOCKET_ADDRESS_TYPE_FD,
++                          remote, errp);
++    if (!s) {
++        return -1;
++    }
++
++    s->dgram_dst = saddr;
++
++    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr.sin_addr),
++                      ntohs(saddr.sin_port));
++    return 0;
++
++}
++
++
++int net_init_dgram(const Netdev *netdev, const char *name,
++                   NetClientState *peer, Error **errp)
++{
++    NetDgramState *s;
++    int fd, ret;
++    struct sockaddr_in raddr_in;
++    struct sockaddr_in laddr_in;
++    SocketAddress *remote, *local;
++
++    assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
++
++    remote = netdev->u.dgram.remote;
++    local = netdev->u.dgram.local;
++
++    /* detect multicast address */
++    if (remote && remote->type == SOCKET_ADDRESS_TYPE_INET) {
++        struct sockaddr_in mcastaddr;
++
++        if (convert_host_port(&mcastaddr, remote->u.inet.host,
++                              remote->u.inet.port, errp) < 0) {
++            return -1;
++        }
++
++        if (IN_MULTICAST(ntohl(mcastaddr.sin_addr.s_addr))) {
++            return net_dgram_mcast_init(peer, "dram", name, remote, local,
++                                           errp);
++        }
++    }
++
++    /* unicast address */
++    if (!local) {
++        error_setg(errp, "dgram requires local= parameter");
++        return -1;
++    }
++
++    if (remote) {
++        if (local->type == SOCKET_ADDRESS_TYPE_FD) {
++            error_setg(errp, "don't set remote with local.fd");
++            return -1;
++        }
++        if (remote->type != local->type) {
++            error_setg(errp, "remote and local types must be the same");
++            return -1;
++        }
++    } else {
++        if (local->type != SOCKET_ADDRESS_TYPE_FD) {
++            error_setg(errp, "type=inet requires remote parameter");
++            return -1;
++        }
++    }
++
++    switch (local->type) {
++    case SOCKET_ADDRESS_TYPE_INET:
++        if (convert_host_port(&laddr_in, local->u.inet.host, local->u.inet.port,
++                              errp) < 0) {
++            return -1;
++        }
++
++        if (convert_host_port(&raddr_in, remote->u.inet.host,
++                              remote->u.inet.port, errp) < 0) {
++            return -1;
++        }
++
++        fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
++        if (fd < 0) {
++            error_setg_errno(errp, errno, "can't create datagram socket");
++            return -1;
++        }
++
++        ret = socket_set_fast_reuse(fd);
++        if (ret < 0) {
++            error_setg_errno(errp, errno,
++                             "can't set socket option SO_REUSEADDR");
++            closesocket(fd);
++            return -1;
++        }
++        ret = bind(fd, (struct sockaddr *)&laddr_in, sizeof(laddr_in));
++        if (ret < 0) {
++            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
++                             inet_ntoa(laddr_in.sin_addr));
++            closesocket(fd);
++            return -1;
++        }
++        qemu_socket_set_nonblock(fd);
++        break;
++    case SOCKET_ADDRESS_TYPE_FD:
++        fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
++        if (fd == -1) {
++            return -1;
++        }
++        ret = qemu_socket_try_set_nonblock(fd);
++        if (ret < 0) {
++            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
++                             name, fd);
++            return -1;
++        }
++        break;
++    default:
++        error_setg(errp, "only support inet or fd type for local");
++        return -1;
++    }
++
++    s = net_dgram_fd_init(peer, "dgram", name, fd, 0, NULL, errp);
++    if (!s) {
++        return -1;
++    }
++
++    if (remote) {
++        s->dgram_dst = raddr_in;
++    }
++
++    switch (local->type) {
++    case SOCKET_ADDRESS_TYPE_INET:
++        qemu_set_info_str(&s->nc, "udp=%s:%d/%s:%d",
++                          inet_ntoa(laddr_in.sin_addr),
++                          ntohs(laddr_in.sin_port),
++                          inet_ntoa(raddr_in.sin_addr),
++                          ntohs(raddr_in.sin_port));
++        break;
++    case SOCKET_ADDRESS_TYPE_FD:
++        qemu_set_info_str(&s->nc, "fd=%d", fd);
++        break;
++    default:
++        g_assert_not_reached();
++    }
++
++    return 0;
++}
 diff --git a/net/hub.c b/net/hub.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/hub.c
 +++ b/net/hub.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void net_hub_check_clients(void)
-  */
+             case NET_CLIENT_DRIVER_USER:
+             case NET_CLIENT_DRIVER_TAP:
- #include "qemu/osdep.h"
+             case NET_CLIENT_DRIVER_SOCKET:
-+#include "qapi/error.h"
++            case NET_CLIENT_DRIVER_STREAM:
- #include "monitor/monitor.h"
++            case NET_CLIENT_DRIVER_DGRAM:
- #include "net/net.h"
+             case NET_CLIENT_DRIVER_VDE:
- #include "clients.h"
+             case NET_CLIENT_DRIVER_VHOST_USER:
-@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_hub_port_info = {
+                 has_host_dev = 1;
-     .cleanup = net_hub_port_cleanup,
+diff --git a/net/meson.build b/net/meson.build
  };
 -static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
 +static NetHubPort *net_hub_port_new(NetHub *hub, const char *name,
 +                                    NetClientState *hubpeer)
  {
      NetClientState *nc;
      NetHubPort *port;
@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
          name = default_name;
      }
 -    nc = qemu_new_net_client(&net_hub_port_info, NULL, "hub", name);
 +    nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name);
      port = DO_UPCAST(NetHubPort, nc, nc);
      port->id = id;
      port->hub = hub;
@@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name)
  /**
   * Create a port on a given hub
 + * @hub_id: Number of the hub
   * @name: Net client name or NULL for default name.
 + * @hubpeer: Peer to use (if "netdev=id" has been specified)
   *
   * If there is no existing hub with the given id then a new hub is created.
   */
 -NetClientState *net_hub_add_port(int hub_id, const char *name)
 +NetClientState *net_hub_add_port(int hub_id, const char *name,
 +                                 NetClientState *hubpeer)
  {
      NetHub *hub;
      NetHubPort *port;
@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_add_port(int hub_id, const char *name)
          hub = net_hub_new(hub_id);
      }
 -    port = net_hub_port_new(hub, name);
 +    port = net_hub_port_new(hub, name, hubpeer);
      return &port->nc;
  }
@@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id)
          }
      }
 -    nc = net_hub_add_port(hub_id, NULL);
 +    nc = net_hub_add_port(hub_id, NULL, NULL);
      return nc;
  }
@@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name,
                       NetClientState *peer, Error **errp)
  {
      const NetdevHubPortOptions *hubport;
 +    NetClientState *hubpeer = NULL;
      assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT);
      assert(!peer);
      hubport = &netdev->u.hubport;
 -    net_hub_add_port(hubport->hubid, name);
 +    if (hubport->has_netdev) {
 +        hubpeer = qemu_find_netdev(hubport->netdev);
 +        if (!hubpeer) {
 +            error_setg(errp, "netdev '%s' not found", hubport->netdev);
 +            return -1;
 +        }
 +    }
 +
 +    net_hub_add_port(hubport->hubid, name, hubpeer);
 +
      return 0;
  }
 diff --git a/net/hub.h b/net/hub.h
 index XXXXXXX..XXXXXXX 100644
---- a/net/hub.h
+--- a/net/meson.build
-+++ b/net/hub.h
++++ b/net/meson.build
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ softmmu_ss.add(files(
+   'net.c',
- #include "qemu-common.h"
+   'queue.c',
+   'socket.c',
--NetClientState *net_hub_add_port(int hub_id, const char *name);
++  'stream.c',
-+NetClientState *net_hub_add_port(int hub_id, const char *name,
++  'dgram.c',
-+                                 NetClientState *hubpeer);
+   'util.c',
- NetClientState *net_hub_find_client_by_name(int hub_id, const char *name);
+ ))
- void net_hub_info(Monitor *mon);
  void net_hub_check_clients(void);
 diff --git a/net/net.c b/net/net.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/net.c
 +++ b/net/net.c
-@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp)
+@@ -XXX,XX +XXX,XX @@
-         /* Do not add to a vlan if it's a nic with a netdev= parameter. */
+ #include "qemu/qemu-print.h"
-         if (netdev->type != NET_CLIENT_DRIVER_NIC ||
+ #include "qemu/main-loop.h"
-             !opts->u.nic.has_netdev) {
+ #include "qemu/option.h"
--            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL);
++#include "qemu/keyval.h"
-+            peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL, NULL);
+ #include "qapi/error.h"
-         }
+ #include "qapi/opts-visitor.h"
+ #include "sysemu/runstate.h"
-         if (net->has_vlan && !vlan_warned) {
+@@ -XXX,XX +XXX,XX @@ static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
  #endif
          [NET_CLIENT_DRIVER_TAP]       = net_init_tap,
          [NET_CLIENT_DRIVER_SOCKET]    = net_init_socket,
 +        [NET_CLIENT_DRIVER_STREAM]    = net_init_stream,
 +        [NET_CLIENT_DRIVER_DGRAM]     = net_init_dgram,
  #ifdef CONFIG_VDE
          [NET_CLIENT_DRIVER_VDE]       = net_init_vde,
  #endif
@@ -XXX,XX +XXX,XX @@ void show_netdevs(void)
      int idx;
      const char *available_netdevs[] = {
          "socket",
 +        "stream",
 +        "dgram",
          "hubport",
          "tap",
  #ifdef CONFIG_SLIRP
@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
   */
  bool netdev_is_modern(const char *optarg)
  {
 -    return false;
 +    QemuOpts *opts;
 +    bool is_modern;
 +    const char *type;
 +    static QemuOptsList dummy_opts = {
 +        .name = "netdev",
 +        .implied_opt_name = "type",
 +        .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
 +        .desc = { { } },
 +    };
 +
 +    if (optarg[0] == '{') {
 +        /* This is JSON, which means it's modern syntax */
 +        return true;
 +    }
 +
 +    opts = qemu_opts_create(&dummy_opts, NULL, false, &error_abort);
 +    qemu_opts_do_parse(opts, optarg, dummy_opts.implied_opt_name,
 +                       &error_abort);
 +    type = qemu_opt_get(opts, "type");
 +    is_modern = !g_strcmp0(type, "stream") || !g_strcmp0(type, "dgram");
 +
 +    qemu_opts_reset(&dummy_opts);
 +
 +    return is_modern;
  }
  /*
 diff --git a/net/stream.c b/net/stream.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QEMU System Emulator
 + *
 + * Copyright (c) 2003-2008 Fabrice Bellard
 + * Copyright (c) 2022 Red Hat, Inc.
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
 +#include "qemu/osdep.h"
 +
 +#include "net/net.h"
 +#include "clients.h"
 +#include "monitor/monitor.h"
 +#include "qapi/error.h"
 +#include "qemu/error-report.h"
 +#include "qemu/option.h"
 +#include "qemu/sockets.h"
 +#include "qemu/iov.h"
 +#include "qemu/main-loop.h"
 +#include "qemu/cutils.h"
 +
 +typedef struct NetStreamState {
 +    NetClientState nc;
 +    int listen_fd;
 +    int fd;
 +    SocketReadState rs;
 +    unsigned int send_index;      /* number of bytes sent*/
 +    bool read_poll;               /* waiting to receive data? */
 +    bool write_poll;              /* waiting to transmit data? */
 +} NetStreamState;
 +
 +static void net_stream_send(void *opaque);
 +static void net_stream_accept(void *opaque);
 +static void net_stream_writable(void *opaque);
 +
 +static void net_stream_update_fd_handler(NetStreamState *s)
 +{
 +    qemu_set_fd_handler(s->fd,
 +                        s->read_poll ? net_stream_send : NULL,
 +                        s->write_poll ? net_stream_writable : NULL,
 +                        s);
 +}
 +
 +static void net_stream_read_poll(NetStreamState *s, bool enable)
 +{
 +    s->read_poll = enable;
 +    net_stream_update_fd_handler(s);
 +}
 +
 +static void net_stream_write_poll(NetStreamState *s, bool enable)
 +{
 +    s->write_poll = enable;
 +    net_stream_update_fd_handler(s);
 +}
 +
 +static void net_stream_writable(void *opaque)
 +{
 +    NetStreamState *s = opaque;
 +
 +    net_stream_write_poll(s, false);
 +
 +    qemu_flush_queued_packets(&s->nc);
 +}
 +
 +static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
 +                                  size_t size)
 +{
 +    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
 +    uint32_t len = htonl(size);
 +    struct iovec iov[] = {
 +        {
 +            .iov_base = &len,
 +            .iov_len  = sizeof(len),
 +        }, {
 +            .iov_base = (void *)buf,
 +            .iov_len  = size,
 +        },
 +    };
 +    size_t remaining;
 +    ssize_t ret;
 +
 +    remaining = iov_size(iov, 2) - s->send_index;
 +    ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
 +
 +    if (ret == -1 && errno == EAGAIN) {
 +        ret = 0; /* handled further down */
 +    }
 +    if (ret == -1) {
 +        s->send_index = 0;
 +        return -errno;
 +    }
 +    if (ret < (ssize_t)remaining) {
 +        s->send_index += ret;
 +        net_stream_write_poll(s, true);
 +        return 0;
 +    }
 +    s->send_index = 0;
 +    return size;
 +}
 +
 +static void net_stream_send_completed(NetClientState *nc, ssize_t len)
 +{
 +    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
 +
 +    if (!s->read_poll) {
 +        net_stream_read_poll(s, true);
 +    }
 +}
 +
 +static void net_stream_rs_finalize(SocketReadState *rs)
 +{
 +    NetStreamState *s = container_of(rs, NetStreamState, rs);
 +
 +    if (qemu_send_packet_async(&s->nc, rs->buf,
 +                               rs->packet_len,
 +                               net_stream_send_completed) == 0) {
 +        net_stream_read_poll(s, false);
 +    }
 +}
 +
 +static void net_stream_send(void *opaque)
 +{
 +    NetStreamState *s = opaque;
 +    int size;
 +    int ret;
 +    uint8_t buf1[NET_BUFSIZE];
 +    const uint8_t *buf;
 +
 +    size = recv(s->fd, buf1, sizeof(buf1), 0);
 +    if (size < 0) {
 +        if (errno != EWOULDBLOCK) {
 +            goto eoc;
 +        }
 +    } else if (size == 0) {
 +        /* end of connection */
 +    eoc:
 +        net_stream_read_poll(s, false);
 +        net_stream_write_poll(s, false);
 +        if (s->listen_fd != -1) {
 +            qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
 +        }
 +        closesocket(s->fd);
 +
 +        s->fd = -1;
 +        net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
 +        s->nc.link_down = true;
 +        qemu_set_info_str(&s->nc, "");
 +
 +        return;
 +    }
 +    buf = buf1;
 +
 +    ret = net_fill_rstate(&s->rs, buf, size);
 +
 +    if (ret == -1) {
 +        goto eoc;
 +    }
 +}
 +
 +static void net_stream_cleanup(NetClientState *nc)
 +{
 +    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
 +    if (s->fd != -1) {
 +        net_stream_read_poll(s, false);
 +        net_stream_write_poll(s, false);
 +        close(s->fd);
 +        s->fd = -1;
 +    }
 +    if (s->listen_fd != -1) {
 +        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
 +        closesocket(s->listen_fd);
 +        s->listen_fd = -1;
 +    }
 +}
 +
 +static void net_stream_connect(void *opaque)
 +{
 +    NetStreamState *s = opaque;
 +    net_stream_read_poll(s, true);
 +}
 +
 +static NetClientInfo net_stream_info = {
 +    .type = NET_CLIENT_DRIVER_STREAM,
 +    .size = sizeof(NetStreamState),
 +    .receive = net_stream_receive,
 +    .cleanup = net_stream_cleanup,
 +};
 +
 +static NetStreamState *net_stream_fd_init(NetClientState *peer,
 +                                          const char *model,
 +                                          const char *name,
 +                                          int fd, int is_connected)
 +{
 +    NetClientState *nc;
 +    NetStreamState *s;
 +
 +    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
 +
 +    qemu_set_info_str(nc, "fd=%d", fd);
 +
 +    s = DO_UPCAST(NetStreamState, nc, nc);
 +
 +    s->fd = fd;
 +    s->listen_fd = -1;
 +    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
 +
 +    /* Disable Nagle algorithm on TCP sockets to reduce latency */
 +    socket_set_nodelay(fd);
 +
 +    if (is_connected) {
 +        net_stream_connect(s);
 +    } else {
 +        qemu_set_fd_handler(s->fd, NULL, net_stream_connect, s);
 +    }
 +    return s;
 +}
 +
 +static void net_stream_accept(void *opaque)
 +{
 +    NetStreamState *s = opaque;
 +    struct sockaddr_in saddr;
 +    socklen_t len;
 +    int fd;
 +
 +    for (;;) {
 +        len = sizeof(saddr);
 +        fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
 +        if (fd < 0 && errno != EINTR) {
 +            return;
 +        } else if (fd >= 0) {
 +            qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
 +            break;
 +        }
 +    }
 +
 +    s->fd = fd;
 +    s->nc.link_down = false;
 +    net_stream_connect(s);
 +    qemu_set_info_str(&s->nc, "connection from %s:%d",
 +                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +}
 +
 +static int net_stream_server_init(NetClientState *peer,
 +                                  const char *model,
 +                                  const char *name,
 +                                  SocketAddress *addr,
 +                                  Error **errp)
 +{
 +    NetClientState *nc;
 +    NetStreamState *s;
 +    int fd, ret;
 +
 +    switch (addr->type) {
 +    case SOCKET_ADDRESS_TYPE_INET: {
 +        struct sockaddr_in saddr_in;
 +
 +        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
 +                              errp) < 0) {
 +            return -1;
 +        }
 +
 +        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 +        if (fd < 0) {
 +            error_setg_errno(errp, errno, "can't create stream socket");
 +            return -1;
 +        }
 +        qemu_socket_set_nonblock(fd);
 +
 +        socket_set_fast_reuse(fd);
 +
 +        ret = bind(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
 +        if (ret < 0) {
 +            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
 +                             inet_ntoa(saddr_in.sin_addr));
 +            closesocket(fd);
 +            return -1;
 +        }
 +        break;
 +    }
 +    case SOCKET_ADDRESS_TYPE_FD:
 +        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
 +        if (fd == -1) {
 +            return -1;
 +        }
 +        ret = qemu_socket_try_set_nonblock(fd);
 +        if (ret < 0) {
 +            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
 +                             name, fd);
 +            return -1;
 +        }
 +        break;
 +    default:
 +        error_setg(errp, "only support inet or fd type");
 +        return -1;
 +    }
 +
 +    ret = listen(fd, 0);
 +    if (ret < 0) {
 +        error_setg_errno(errp, errno, "can't listen on socket");
 +        closesocket(fd);
 +        return -1;
 +    }
 +
 +    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
 +    s = DO_UPCAST(NetStreamState, nc, nc);
 +    s->fd = -1;
 +    s->listen_fd = fd;
 +    s->nc.link_down = true;
 +    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
 +
 +    qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
 +    return 0;
 +}
 +
 +static int net_stream_client_init(NetClientState *peer,
 +                                  const char *model,
 +                                  const char *name,
 +                                  SocketAddress *addr,
 +                                  Error **errp)
 +{
 +    NetStreamState *s;
 +    struct sockaddr_in saddr_in;
 +    int fd, connected, ret;
 +
 +    switch (addr->type) {
 +    case SOCKET_ADDRESS_TYPE_INET:
 +        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
 +                              errp) < 0) {
 +            return -1;
 +        }
 +
 +        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
 +        if (fd < 0) {
 +            error_setg_errno(errp, errno, "can't create stream socket");
 +            return -1;
 +        }
 +        qemu_socket_set_nonblock(fd);
 +
 +        connected = 0;
 +        for (;;) {
 +            ret = connect(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
 +            if (ret < 0) {
 +                if (errno == EINTR || errno == EWOULDBLOCK) {
 +                    /* continue */
 +                } else if (errno == EINPROGRESS ||
 +                           errno == EALREADY ||
 +                           errno == EINVAL) {
 +                    break;
 +                } else {
 +                    error_setg_errno(errp, errno, "can't connect socket");
 +                    closesocket(fd);
 +                    return -1;
 +                }
 +            } else {
 +                connected = 1;
 +                break;
 +            }
 +        }
 +        break;
 +    case SOCKET_ADDRESS_TYPE_FD:
 +        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
 +        if (fd == -1) {
 +            return -1;
 +        }
 +        ret = qemu_socket_try_set_nonblock(fd);
 +        if (ret < 0) {
 +            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
 +                             name, fd);
 +            return -1;
 +        }
 +        connected = 1;
 +        break;
 +    default:
 +        error_setg(errp, "only support inet or fd type");
 +        return -1;
 +    }
 +
 +    s = net_stream_fd_init(peer, model, name, fd, connected);
 +
 +    switch (addr->type) {
 +    case SOCKET_ADDRESS_TYPE_INET:
 +        qemu_set_info_str(&s->nc, "connect to %s:%d",
 +                          inet_ntoa(saddr_in.sin_addr),
 +                          ntohs(saddr_in.sin_port));
 +        break;
 +    case SOCKET_ADDRESS_TYPE_FD:
 +        qemu_set_info_str(&s->nc, "connect to fd %d", fd);
 +        break;
 +    default:
 +        g_assert_not_reached();
 +    }
 +
 +    return 0;
 +}
 +
 +int net_init_stream(const Netdev *netdev, const char *name,
 +                    NetClientState *peer, Error **errp)
 +{
 +    const NetdevStreamOptions *sock;
 +
 +    assert(netdev->type == NET_CLIENT_DRIVER_STREAM);
 +    sock = &netdev->u.stream;
 +
 +    if (!sock->has_server || !sock->server) {
 +        return net_stream_client_init(peer, "stream", name, sock->addr, errp);
 +    }
 +    return net_stream_server_init(peer, "stream", name, sock->addr, errp);
 +}
 diff --git a/qapi/net.json b/qapi/net.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/net.json
 +++ b/qapi/net.json
 @@ -XXX,XX +XXX,XX @@
- # Connect two or more net clients through a software hub.
+ ##
  { 'include': 'common.json' }
 +{ 'include': 'sockets.json' }
  ##
  # @set_link:
@@ -XXX,XX +XXX,XX @@
    'if': 'CONFIG_VMNET' }
  ##
 +# @NetdevStreamOptions:
 +#
 +# Configuration info for stream socket netdev
 +#
 +# @addr: socket address to listen on (server=true)
 +#        or connect to (server=false)
 +# @server: create server socket (default: false)
 +#
 +# Only SocketAddress types 'inet' and 'fd' are supported.
 +#
 +# Since: 7.2
 +##
 +{ 'struct': 'NetdevStreamOptions',
 +  'data': {
 +    'addr':   'SocketAddress',
 +    '*server': 'bool' } }
 +
 +##
 +# @NetdevDgramOptions:
 +#
 +# Configuration info for datagram socket netdev.
 +#
 +# @remote: remote address
 +# @local: local address
 +#
 +# Only SocketAddress types 'inet' and 'fd' are supported.
 +#
 +# If remote address is present and it's a multicast address, local address
 +# is optional. Otherwise local address is required and remote address is
 +# optional.
 +#
 +# .. table:: Valid parameters combination table
 +#    :widths: auto
 +#
 +#    =============  ========  =====
 +#    remote         local     okay?
 +#    =============  ========  =====
 +#    absent         absent    no
 +#    absent         not fd    no
 +#    absent         fd        yes
 +#    multicast      absent    yes
 +#    multicast      present   yes
 +#    not multicast  absent    no
 +#    not multicast  present   yes
 +#    =============  ========  =====
 +#
 +# Since: 7.2
 +##
 +{ 'struct': 'NetdevDgramOptions',
 +  'data': {
 +    '*local':  'SocketAddress',
 +    '*remote': 'SocketAddress' } }
 +
 +##
  # @NetClientDriver:
  #
- # @hubid: hub identifier number
+ # Available netdev drivers.
-+# @netdev: used to connect hub to a netdev instead of a device (since 2.12)
+@@ -XXX,XX +XXX,XX @@
- #
+ #        @vmnet-host since 7.1
- # Since: 1.2
+ #        @vmnet-shared since 7.1
  #        @vmnet-bridged since 7.1
 +#        @stream since 7.2
 +#        @dgram since 7.2
  ##
- { 'struct': 'NetdevHubPortOptions',
+ { 'enum': 'NetClientDriver',
-   'data': {
+-  'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'vde',
--    'hubid':     'int32' } }
+-            'bridge', 'hubport', 'netmap', 'vhost-user', 'vhost-vdpa',
-+    'hubid':     'int32',
++  'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'stream',
-+    '*netdev':    'str' } }
++            'dgram', 'vde', 'bridge', 'hubport', 'netmap', 'vhost-user',
++            'vhost-vdpa',
              { 'name': 'vmnet-host', 'if': 'CONFIG_VMNET' },
              { 'name': 'vmnet-shared', 'if': 'CONFIG_VMNET' },
              { 'name': 'vmnet-bridged', 'if': 'CONFIG_VMNET' }] }
@@ -XXX,XX +XXX,XX @@
  #        'vmnet-host' - since 7.1
  #        'vmnet-shared' - since 7.1
  #        'vmnet-bridged' - since 7.1
 +#        'stream' since 7.2
 +#        'dgram' since 7.2
  ##
- # @NetdevNetmapOptions:
+ { 'union': 'Netdev',
    'base': { 'id': 'str', 'type': 'NetClientDriver' },
@@ -XXX,XX +XXX,XX @@
      'tap':      'NetdevTapOptions',
      'l2tpv3':   'NetdevL2TPv3Options',
      'socket':   'NetdevSocketOptions',
 +    'stream':   'NetdevStreamOptions',
 +    'dgram':    'NetdevDgramOptions',
      'vde':      'NetdevVdeOptions',
      'bridge':   'NetdevBridgeOptions',
      'hubport':  'NetdevHubPortOptions',
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
 @@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
- #endif
+     "-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"
-     "-netdev vhost-user,id=str,chardev=dev[,vhostforce=on|off]\n"
+     "                configure a network backend to connect to another network\n"
-     "                configure a vhost-user network, backed by a chardev 'dev'\n"
+     "                using an UDP tunnel\n"
--    "-netdev hubport,id=str,hubid=n\n"
++    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
-+    "-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
++    "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
-     "                configure a hub port on QEMU VLAN 'n'\n", QEMU_ARCH_ALL)
++    "                configure a network backend to connect to another network\n"
- DEF("net", HAS_ARG, QEMU_OPTION_net,
++    "                using a socket connection in stream mode.\n"
-     "-net nic[,vlan=n][,netdev=nd][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n"
++    "-netdev dgram,id=str,remote.type=inet,remote.host=maddr,remote.port=port[,local.type=inet,local.host=addr]\n"
-@@ -XXX,XX +XXX,XX @@ vde_switch -F -sock /tmp/myswitch
++    "-netdev dgram,id=str,remote.type=inet,remote.host=maddr,remote.port=port[,local.type=fd,local.str=file-descriptor]\n"
- qemu-system-i386 linux.img -net nic -net vde,sock=/tmp/myswitch
++    "                configure a network backend to connect to a multicast maddr and port\n"
- @end example
++    "                use ``local.host=addr`` to specify the host address to send packets from\n"
++    "-netdev dgram,id=str,local.type=inet,local.host=addr,local.port=port[,remote.type=inet,remote.host=addr,remote.port=port]\n"
--@item -netdev hubport,id=@var{id},hubid=@var{hubid}
++    "-netdev dgram,id=str,local.type=fd,local.str=file-descriptor\n"
-+@item -netdev hubport,id=@var{id},hubid=@var{hubid}[,netdev=@var{nd}]
++    "                configure a network backend to connect to another network\n"
++    "                using an UDP tunnel\n"
- Create a hub port on QEMU "vlan" @var{hubid}.
+ #ifdef CONFIG_VDE
+     "-netdev vde,id=str[,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
- The hubport netdev lets you connect a NIC to a QEMU "vlan" instead of a single
+     "                configure a network backend to connect to port 'n' of a vde switch\n"
  netdev.  @code{-net} and @code{-device} with parameter @option{vlan} create the
 -required hub automatically.
 +required hub automatically. Alternatively, you can also connect the hubport
 +to another netdev with ID @var{nd} by using the @option{netdev=@var{nd}}
 +option.
  @item -netdev vhost-user,chardev=@var{id}[,vhostforce=on|off][,queues=n]
 --
 .7.4

-New patch
+[PULL 17/26] net: socket: Don't ignore EINVAL on netdev socket connection
+From: Stefano Brivio <sbrivio@redhat.com>
+Other errors are treated as failure by net_socket_connect_init(),
+but if connect() returns EINVAL, we'll fail silently. Remove the
+related exception.
+Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/socket.c | 3 +--
+file changed, 1 insertion(+), 2 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 int net_socket_connect_init(NetClientState *peer,
+             if (errno == EINTR || errno == EWOULDBLOCK) {
+                 /* continue */
+             } else if (errno == EINPROGRESS ||
+-                       errno == EALREADY ||
+-                       errno == EINVAL) {
++                       errno == EALREADY) {
+                 break;
+             } else {
+                 error_setg_errno(errp, errno, "can't connect socket");
+--
+.7.4

-New patch
+[PULL 18/26] net: stream: Don't ignore EINVAL on netdev socket connection
+From: Stefano Brivio <sbrivio@redhat.com>
+Other errors are treated as failure by net_stream_client_init(),
+but if connect() returns EINVAL, we'll fail silently. Remove the
+related exception.
+Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
+[lvivier: applied to net/stream.c]
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/stream.c | 3 +--
+file changed, 1 insertion(+), 2 deletions(-)
+diff --git a/net/stream.c b/net/stream.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/stream.c
++++ b/net/stream.c
+@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
+                 if (errno == EINTR || errno == EWOULDBLOCK) {
+                     /* continue */
+                 } else if (errno == EINPROGRESS ||
+-                           errno == EALREADY ||
+-                           errno == EINVAL) {
++                           errno == EALREADY) {
+                     break;
+                 } else {
+                     error_setg_errno(errp, errno, "can't connect socket");
+--
+.7.4

-[Qemu-devel] [PULL 1/6] colo: modified the payload compare function
+[PULL 19/26] net: stream: add unix socket
-From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
+From: Laurent Vivier <lvivier@redhat.com>
-Modified the function colo_packet_compare_common to prepare for the
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
-tcp packet comparison in the next patch.
+Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
-Cc: Zhang Chen <zhangckid@gmail.com>
+Acked-by: Markus Armbruster <armbru@redhat.com> (QAPI schema)
-Cc: Li Zhijian <lizhijian@cn.fujitsu.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
 Cc: Jason Wang <jasowang@redhat.com>
 Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>
 Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
 Signed-off-by: Zhang Chen <zhangckid@gmail.com>
 Reviewed-by: Zhang Chen <zhangckid@gmail.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 88 +++++++++++++++++++++++++++---------------------------
+ net/stream.c    | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++---
-file changed, 44 insertions(+), 44 deletions(-)
+ qapi/net.json   |   2 +-
+ qemu-options.hx |   1 +
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+files changed, 104 insertions(+), 6 deletions(-)
 diff --git a/net/stream.c b/net/stream.c
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/net/stream.c
-+++ b/net/colo-compare.c
++++ b/net/stream.c
-@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con)
+@@ -XXX,XX +XXX,XX @@ static NetStreamState *net_stream_fd_init(NetClientState *peer,
-  * return:    0  means packet same
+ static void net_stream_accept(void *opaque)
   *            > 0 || < 0 means packet different
   */
 -static int colo_packet_compare_common(Packet *ppkt,
 -                                      Packet *spkt,
 -                                      int poffset,
 -                                      int soffset)
 +static int colo_compare_packet_payload(Packet *ppkt,
 +                                       Packet *spkt,
 +                                       uint16_t poffset,
 +                                       uint16_t soffset,
 +                                       uint16_t len)
 +
  {
-     if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
+     NetStreamState *s = opaque;
-         char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
+-    struct sockaddr_in saddr;
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_common(Packet *ppkt,
++    struct sockaddr_storage saddr;
-                                    sec_ip_src, sec_ip_dst);
+     socklen_t len;
      int fd;
@@ -XXX,XX +XXX,XX @@ static void net_stream_accept(void *opaque)
      s->fd = fd;
      s->nc.link_down = false;
      net_stream_connect(s);
 -    qemu_set_info_str(&s->nc, "connection from %s:%d",
 -                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +    switch (saddr.ss_family) {
 +    case AF_INET: {
 +        struct sockaddr_in *saddr_in = (struct sockaddr_in *)&saddr;
 +
 +        qemu_set_info_str(&s->nc, "connection from %s:%d",
 +                          inet_ntoa(saddr_in->sin_addr),
 +                          ntohs(saddr_in->sin_port));
 +        break;
 +    }
 +    case AF_UNIX: {
 +        struct sockaddr_un saddr_un;
 +
 +        len = sizeof(saddr_un);
 +        getsockname(s->listen_fd, (struct sockaddr *)&saddr_un, &len);
 +        qemu_set_info_str(&s->nc, "connect from %s", saddr_un.sun_path);
 +        break;
 +    }
 +    default:
 +        g_assert_not_reached();
 +    }
  }
  static int net_stream_server_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_stream_server_init(NetClientState *peer,
          }
          break;
      }
++    case SOCKET_ADDRESS_TYPE_UNIX: {
--    poffset = ppkt->vnet_hdr_len + poffset;
++        struct sockaddr_un saddr_un;
--    soffset = ppkt->vnet_hdr_len + soffset;
++
--
++        ret = unlink(addr->u.q_unix.path);
--    if (ppkt->size - poffset == spkt->size - soffset) {
++        if (ret < 0 && errno != ENOENT) {
--        return memcmp(ppkt->data + poffset,
++            error_setg_errno(errp, errno, "failed to unlink socket %s",
--                      spkt->data + soffset,
++                             addr->u.q_unix.path);
--                      spkt->size - soffset);
++            return -1;
--    } else {
++        }
--        trace_colo_compare_main("Net packet size are not the same");
++
--        return -1;
++        saddr_un.sun_family = PF_UNIX;
--    }
++        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
-+    return memcmp(ppkt->data + poffset, spkt->data + soffset, len);
++                       addr->u.q_unix.path);
- }
++        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
++            error_setg(errp, "UNIX socket path '%s' is too long",
- /*
++                       addr->u.q_unix.path);
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
++            error_append_hint(errp, "Path must be less than %zu bytes\n",
-      * the secondary guest's timestamp. COLO just focus on payload,
++                              sizeof(saddr_un.sun_path));
-      * so we just need skip this field.
++            return -1;
-      */
++        }
--    if (ptcp->th_off > 5) {
++
--        ptrdiff_t ptcp_offset, stcp_offset;
++        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
++        if (fd < 0) {
--        ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
++            error_setg_errno(errp, errno, "can't create stream socket");
--                      + (ptcp->th_off * 4) - ppkt->vnet_hdr_len;
++            return -1;
--        stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
++        }
--                      + (stcp->th_off * 4) - spkt->vnet_hdr_len;
++        qemu_socket_set_nonblock(fd);
-+    ptrdiff_t ptcp_offset, stcp_offset;
++
++        ret = bind(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
--        /*
++        if (ret < 0) {
--         * When network is busy, some tcp options(like sack) will unpredictable
++            error_setg_errno(errp, errno, "can't create socket with path: %s",
--         * occur in primary side or secondary side. it will make packet size
++                             saddr_un.sun_path);
--         * not same, but the two packet's payload is identical. colo just
++            closesocket(fd);
--         * care about packet payload, so we skip the option field.
++            return -1;
--         */
++        }
--        res = colo_packet_compare_common(ppkt, spkt, ptcp_offset, stcp_offset);
++        break;
--    } else if (ptcp->th_sum == stcp->th_sum) {
++    }
--        res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN, ETH_HLEN);
+     case SOCKET_ADDRESS_TYPE_FD:
-+    ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data
+         fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
-+                  + (ptcp->th_off << 2) - ppkt->vnet_hdr_len;
+         if (fd == -1) {
-+    stcp_offset = spkt->transport_header - (uint8_t *)spkt->data
+@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
-+                  + (stcp->th_off << 2) - spkt->vnet_hdr_len;
+ {
-+    if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) {
+     NetStreamState *s;
-+        res = colo_compare_packet_payload(ppkt, spkt,
+     struct sockaddr_in saddr_in;
-+                                          ptcp_offset, stcp_offset,
++    struct sockaddr_un saddr_un;
-+                                          ppkt->size - ptcp_offset);
+     int fd, connected, ret;
-     } else {
-+        trace_colo_compare_main("TCP: payload size of packets are different");
+     switch (addr->type) {
-         res = -1;
+@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
              }
          }
          break;
 +    case SOCKET_ADDRESS_TYPE_UNIX:
 +        saddr_un.sun_family = PF_UNIX;
 +        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
 +                       addr->u.q_unix.path);
 +        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
 +            error_setg(errp, "UNIX socket path '%s' is too long",
 +                       addr->u.q_unix.path);
 +            error_append_hint(errp, "Path must be less than %zu bytes\n",
 +                              sizeof(saddr_un.sun_path));
 +            return -1;
 +        }
 +
 +        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
 +        if (fd < 0) {
 +            error_setg_errno(errp, errno, "can't create stream socket");
 +            return -1;
 +        }
 +        qemu_socket_set_nonblock(fd);
 +
 +        connected = 0;
 +        for (;;) {
 +            ret = connect(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
 +            if (ret < 0) {
 +                if (errno == EINTR || errno == EWOULDBLOCK) {
 +                    /* continue */
 +                } else if (errno == EAGAIN ||
 +                           errno == EALREADY) {
 +                    break;
 +                } else {
 +                    error_setg_errno(errp, errno, "can't connect socket");
 +                    closesocket(fd);
 +                    return -1;
 +                }
 +            } else {
 +                connected = 1;
 +                break;
 +            }
 +        }
 +        break;
      case SOCKET_ADDRESS_TYPE_FD:
          fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
          if (fd == -1) {
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
          connected = 1;
          break;
      default:
 -        error_setg(errp, "only support inet or fd type");
 +        error_setg(errp, "only support inet, unix or fd type");
          return -1;
      }
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
+@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
-  */
+                           inet_ntoa(saddr_in.sin_addr),
- static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
+                           ntohs(saddr_in.sin_port));
- {
+         break;
--    int ret;
++    case SOCKET_ADDRESS_TYPE_UNIX:
--    int network_header_length = ppkt->ip->ip_hl * 4;
++        qemu_set_info_str(&s->nc, " connect to %s", saddr_un.sun_path);
-+    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
++        break;
-+    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
+     case SOCKET_ADDRESS_TYPE_FD:
+         qemu_set_info_str(&s->nc, "connect to fd %d", fd);
-     trace_colo_compare_main("compare udp");
+         break;
+     default:
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
+         g_assert_not_reached();
       * other field like TOS,TTL,IP Checksum. we only need to compare
       * the ip payload here.
       */
 -    ret = colo_packet_compare_common(ppkt, spkt,
 -                                     network_header_length + ETH_HLEN,
 -                                     network_header_length + ETH_HLEN);
 -
 -    if (ret) {
 +    if (ppkt->size != spkt->size) {
 +        trace_colo_compare_main("UDP: payload size of packets are different");
 +        return -1;
 +    }
 +    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
 +                                    ppkt->size - offset)) {
          trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size);
          trace_colo_compare_udp_miscompare("Secondary pkt size", spkt->size);
          if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
              qemu_hexdump((char *)spkt->data, stderr, "colo-compare sec pkt",
                           spkt->size);
          }
 +        return -1;
 +    } else {
 +        return 0;
      }
 -
--    return ret;
+     return 0;
  }
- /*
+diff --git a/qapi/net.json b/qapi/net.json
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
+index XXXXXXX..XXXXXXX 100644
-  */
+--- a/qapi/net.json
- static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
++++ b/qapi/net.json
- {
+@@ -XXX,XX +XXX,XX @@
--    int network_header_length = ppkt->ip->ip_hl * 4;
+ #        or connect to (server=false)
-+    uint16_t network_header_length = ppkt->ip->ip_hl << 2;
+ # @server: create server socket (default: false)
-+    uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len;
+ #
+-# Only SocketAddress types 'inet' and 'fd' are supported.
-     trace_colo_compare_main("compare icmp");
++# Only SocketAddress types 'unix', 'inet' and 'fd' are supported.
+ #
-@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
+ # Since: 7.2
-      * other field like TOS,TTL,IP Checksum. we only need to compare
+ ##
-      * the ip payload here.
+diff --git a/qemu-options.hx b/qemu-options.hx
-      */
+index XXXXXXX..XXXXXXX 100644
--    if (colo_packet_compare_common(ppkt, spkt,
+--- a/qemu-options.hx
--                                   network_header_length + ETH_HLEN,
++++ b/qemu-options.hx
--                                   network_header_length + ETH_HLEN)) {
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
-+    if (ppkt->size != spkt->size) {
+     "                configure a network backend to connect to another network\n"
-+        trace_colo_compare_main("ICMP: payload size of packets are different");
+     "                using an UDP tunnel\n"
-+        return -1;
+     "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
-+    }
++    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path\n"
-+    if (colo_compare_packet_payload(ppkt, spkt, offset, offset,
+     "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
-+                                    ppkt->size - offset)) {
+     "                configure a network backend to connect to another network\n"
-         trace_colo_compare_icmp_miscompare("primary pkt size",
+     "                using a socket connection in stream mode.\n"
                                             ppkt->size);
          trace_colo_compare_icmp_miscompare("Secondary pkt size",
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
   */
  static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
  {
 +    uint16_t offset = ppkt->vnet_hdr_len;
 +
      trace_colo_compare_main("compare other");
      if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) {
          char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20];
@@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
                                     sec_ip_src, sec_ip_dst);
      }
 -    return colo_packet_compare_common(ppkt, spkt, 0, 0);
 +    if (ppkt->size != spkt->size) {
 +        trace_colo_compare_main("Other: payload size of packets are different");
 +        return -1;
 +    }
 +    return colo_compare_packet_payload(ppkt, spkt, offset, offset,
 +                                       ppkt->size - offset);
  }
  static int colo_old_packet_check_one(Packet *pkt, int64_t *check_time)
 --
 .7.4

-New patch
+[PULL 20/26] net: dgram: make dgram_dst generic
+From: Laurent Vivier <lvivier@redhat.com>
 dgram_dst is a sockaddr_in structure. To be able to use it with
 unix socket, use a pointer to a generic sockaddr structure.
 Rename it dest_addr, and store socket length in dest_len.
 Signed-off-by: Laurent Vivier <lvivier@redhat.com>
 Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
 Acked-by: Michael S. Tsirkin <mst@redhat.com>
 Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
  net/dgram.c | 82 +++++++++++++++++++++++++++++++++++++++----------------------
 file changed, 53 insertions(+), 29 deletions(-)
 diff --git a/net/dgram.c b/net/dgram.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/dgram.c
 +++ b/net/dgram.c
@@ -XXX,XX +XXX,XX @@ typedef struct NetDgramState {
      NetClientState nc;
      int fd;
      SocketReadState rs;
 -    struct sockaddr_in dgram_dst; /* contains destination iff connectionless */
      bool read_poll;               /* waiting to receive data? */
      bool write_poll;              /* waiting to transmit data? */
 +    /* contains destination iff connectionless */
 +    struct sockaddr *dest_addr;
 +    socklen_t dest_len;
  } NetDgramState;
  static void net_dgram_send(void *opaque);
@@ -XXX,XX +XXX,XX @@ static ssize_t net_dgram_receive(NetClientState *nc,
      ssize_t ret;
      do {
 -        if (s->dgram_dst.sin_family != AF_UNIX) {
 -            ret = sendto(s->fd, buf, size, 0,
 -                         (struct sockaddr *)&s->dgram_dst,
 -                         sizeof(s->dgram_dst));
 +        if (s->dest_addr) {
 +            ret = sendto(s->fd, buf, size, 0, s->dest_addr, s->dest_len);
          } else {
              ret = send(s->fd, buf, size, 0);
          }
@@ -XXX,XX +XXX,XX @@ static void net_dgram_cleanup(NetClientState *nc)
          close(s->fd);
          s->fd = -1;
      }
 +    g_free(s->dest_addr);
 +    s->dest_addr = NULL;
 +    s->dest_len = 0;
  }
  static NetClientInfo net_dgram_socket_info = {
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
                                          SocketAddress *mcast,
                                          Error **errp)
  {
 -    struct sockaddr_in saddr;
 +    struct sockaddr_in *saddr = NULL;
      int newfd;
      NetClientState *nc;
      NetDgramState *s;
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
      qapi_free_SocketAddress(sa);
      /*
 -     * fd passed: multicast: "learn" dgram_dst address from bound address and
 +     * fd passed: multicast: "learn" dest_addr address from bound address and
       * save it. Because this may be "shared" socket from a "master" process,
       * datagrams would be recv() by ONLY ONE process: we must "clone" this
       * dgram socket --jjo
       */
      if (is_fd && mcast != NULL) {
 -            if (convert_host_port(&saddr, mcast->u.inet.host,
 -                                  mcast->u.inet.port, errp) < 0) {
 +            saddr = g_new(struct sockaddr_in, 1);
 +
 +            if (convert_host_port(saddr, mcast->u.inet.host, mcast->u.inet.port,
 +                                  errp) < 0) {
                  goto err;
              }
              /* must be bound */
 -            if (saddr.sin_addr.s_addr == 0) {
 +            if (saddr->sin_addr.s_addr == 0) {
                  error_setg(errp, "can't setup multicast destination address");
                  goto err;
              }
              /* clone dgram socket */
 -            newfd = net_dgram_mcast_create(&saddr, NULL, errp);
 +            newfd = net_dgram_mcast_create(saddr, NULL, errp);
              if (newfd < 0) {
                  goto err;
              }
              /* clone newfd to fd, close newfd */
              dup2(newfd, fd);
              close(newfd);
 -
      }
      nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
      net_dgram_read_poll(s, true);
      /* mcast: save bound address as dst */
 -    if (is_fd && mcast != NULL) {
 -        s->dgram_dst = saddr;
 +    if (saddr) {
 +        g_assert(s->dest_addr == NULL);
 +        s->dest_addr = (struct sockaddr *)saddr;
 +        s->dest_len = sizeof(*saddr);
          qemu_set_info_str(nc, "fd=%d (cloned mcast=%s:%d)", fd,
 -                          inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 +                          inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port));
      } else {
 -        if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
 -            s->dgram_dst.sin_family = AF_UNIX;
 -        }
 -
          qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
      }
      return s;
  err:
 +    g_free(saddr);
      closesocket(fd);
      return NULL;
  }
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
  {
      NetDgramState *s;
      int fd, ret;
 -    struct sockaddr_in saddr;
 +    struct sockaddr_in *saddr;
      if (remote->type != SOCKET_ADDRESS_TYPE_INET) {
          error_setg(errp, "multicast only support inet type");
          return -1;
      }
 -    if (convert_host_port(&saddr, remote->u.inet.host, remote->u.inet.port,
 +    saddr = g_new(struct sockaddr_in, 1);
 +    if (convert_host_port(saddr, remote->u.inet.host, remote->u.inet.port,
                            errp) < 0) {
 +        g_free(saddr);
          return -1;
      }
      if (!local) {
 -        fd = net_dgram_mcast_create(&saddr, NULL, errp);
 +        fd = net_dgram_mcast_create(saddr, NULL, errp);
          if (fd < 0) {
 +            g_free(saddr);
              return -1;
          }
      } else {
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
              struct in_addr localaddr;
              if (inet_aton(local->u.inet.host, &localaddr) == 0) {
 +                g_free(saddr);
                  error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
                             local->u.inet.host);
                  return -1;
              }
 -            fd = net_dgram_mcast_create(&saddr, &localaddr, errp);
 +            fd = net_dgram_mcast_create(saddr, &localaddr, errp);
              if (fd < 0) {
 +                g_free(saddr);
                  return -1;
              }
              break;
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
          case SOCKET_ADDRESS_TYPE_FD:
              fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
              if (fd == -1) {
 +                g_free(saddr);
                  return -1;
              }
              ret = qemu_socket_try_set_nonblock(fd);
              if (ret < 0) {
 +                g_free(saddr);
                  error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
                                   name, fd);
                  return -1;
              }
              break;
          default:
 +            g_free(saddr);
              error_setg(errp, "only support inet or fd type for local");
              return -1;
          }
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
                            local->type == SOCKET_ADDRESS_TYPE_FD,
                            remote, errp);
      if (!s) {
 +        g_free(saddr);
          return -1;
      }
 -    s->dgram_dst = saddr;
 +    g_assert(s->dest_addr == NULL);
 +    s->dest_addr = (struct sockaddr *)saddr;
 +    s->dest_len = sizeof(*saddr);
 +
 +    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr->sin_addr),
 +                      ntohs(saddr->sin_port));
 -    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr.sin_addr),
 -                      ntohs(saddr.sin_port));
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
  {
      NetDgramState *s;
      int fd, ret;
 -    struct sockaddr_in raddr_in;
 -    struct sockaddr_in laddr_in;
      SocketAddress *remote, *local;
 +    struct sockaddr *dest_addr;
 +    struct sockaddr_in laddr_in, raddr_in;
 +    socklen_t dest_len;
      assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
              return -1;
          }
          qemu_socket_set_nonblock(fd);
 +
 +        dest_len = sizeof(raddr_in);
 +        dest_addr = g_malloc(dest_len);
 +        memcpy(dest_addr, &raddr_in, dest_len);
          break;
      case SOCKET_ADDRESS_TYPE_FD:
          fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
                               name, fd);
              return -1;
          }
 +        dest_addr = NULL;
 +        dest_len = 0;
          break;
      default:
          error_setg(errp, "only support inet or fd type for local");
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
      }
      if (remote) {
 -        s->dgram_dst = raddr_in;
 +        g_assert(s->dest_addr == NULL);
 +        s->dest_addr = dest_addr;
 +        s->dest_len = dest_len;
      }
      switch (local->type) {
 --
 .7.4

-New patch
+[PULL 21/26] net: dgram: move mcast specific code from net_socket_fd_init_dgram()
+From: Laurent Vivier <lvivier@redhat.com>
+It is less complex to manage special cases directly in
+net_dgram_mcast_init() and net_dgram_udp_init().
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/dgram.c | 143 ++++++++++++++++++++++++++++++++----------------------------
+file changed, 76 insertions(+), 67 deletions(-)
+diff --git a/net/dgram.c b/net/dgram.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/dgram.c
++++ b/net/dgram.c
+@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_dgram_socket_info = {
+ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
+                                         const char *model,
+                                         const char *name,
+-                                        int fd, int is_fd,
+-                                        SocketAddress *mcast,
++                                        int fd,
+                                         Error **errp)
+ {
+-    struct sockaddr_in *saddr = NULL;
+-    int newfd;
+     NetClientState *nc;
+     NetDgramState *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" dest_addr address from bound address and
+-     * save it. Because this may be "shared" socket from a "master" process,
+-     * datagrams would be recv() by ONLY ONE process: we must "clone" this
+-     * dgram socket --jjo
+-     */
+-
+-    if (is_fd && mcast != NULL) {
+-            saddr = g_new(struct sockaddr_in, 1);
+-
+-            if (convert_host_port(saddr, mcast->u.inet.host, mcast->u.inet.port,
+-                                  errp) < 0) {
+-                goto err;
+-            }
+-            /* must be bound */
+-            if (saddr->sin_addr.s_addr == 0) {
+-                error_setg(errp, "can't setup multicast destination address");
+-                goto err;
+-            }
+-            /* clone dgram socket */
+-            newfd = net_dgram_mcast_create(saddr, NULL, errp);
+-            if (newfd < 0) {
+-                goto err;
+-            }
+-            /* clone newfd to fd, close newfd */
+-            dup2(newfd, fd);
+-            close(newfd);
+-    }
+     nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
+@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
+     net_socket_rs_init(&s->rs, net_dgram_rs_finalize, false);
+     net_dgram_read_poll(s, true);
+-    /* mcast: save bound address as dst */
+-    if (saddr) {
+-        g_assert(s->dest_addr == NULL);
+-        s->dest_addr = (struct sockaddr *)saddr;
+-        s->dest_len = sizeof(*saddr);
+-        qemu_set_info_str(nc, "fd=%d (cloned mcast=%s:%d)", fd,
+-                          inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port));
+-    } else {
+-        qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
+-    }
+-
+     return s;
+-
+-err:
+-    g_free(saddr);
+-    closesocket(fd);
+-    return NULL;
+ }
+ static int net_dgram_mcast_init(NetClientState *peer,
+@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
+             }
+             break;
+         }
+-        case SOCKET_ADDRESS_TYPE_FD:
++        case SOCKET_ADDRESS_TYPE_FD: {
++            int newfd;
++
+             fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
+             if (fd == -1) {
+                 g_free(saddr);
+@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
+                                  name, fd);
+                 return -1;
+             }
++
++            /*
++             * fd passed: multicast: "learn" dest_addr address from bound
++             * address and save it. Because this may be "shared" socket from a
++             * "master" process, datagrams would be recv() by ONLY ONE process:
++             * we must "clone" this dgram socket --jjo
++             */
++
++            saddr = g_new(struct sockaddr_in, 1);
++
++            if (convert_host_port(saddr, local->u.inet.host, local->u.inet.port,
++                                  errp) < 0) {
++                g_free(saddr);
++                closesocket(fd);
++                return -1;
++            }
++
++            /* must be bound */
++            if (saddr->sin_addr.s_addr == 0) {
++                error_setg(errp, "can't setup multicast destination address");
++                g_free(saddr);
++                closesocket(fd);
++                return -1;
++            }
++            /* clone dgram socket */
++            newfd = net_dgram_mcast_create(saddr, NULL, errp);
++            if (newfd < 0) {
++                g_free(saddr);
++                closesocket(fd);
++                return -1;
++            }
++            /* clone newfd to fd, close newfd */
++            dup2(newfd, fd);
++            close(newfd);
+             break;
++        }
+         default:
+             g_free(saddr);
+             error_setg(errp, "only support inet or fd type for local");
+@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
+         }
+     }
+-    s = net_dgram_fd_init(peer, model, name, fd,
+-                          local->type == SOCKET_ADDRESS_TYPE_FD,
+-                          remote, errp);
++    s = net_dgram_fd_init(peer, model, name, fd, errp);
+     if (!s) {
+         g_free(saddr);
+         return -1;
+@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
+     s->dest_addr = (struct sockaddr *)saddr;
+     s->dest_len = sizeof(*saddr);
+-    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr->sin_addr),
+-                      ntohs(saddr->sin_port));
++    if (!local) {
++        qemu_set_info_str(&s->nc, "mcast=%s:%d",
++                          inet_ntoa(saddr->sin_addr),
++                          ntohs(saddr->sin_port));
++    } else {
++        switch (local->type) {
++        case SOCKET_ADDRESS_TYPE_INET:
++            qemu_set_info_str(&s->nc, "mcast=%s:%d",
++                              inet_ntoa(saddr->sin_addr),
++                              ntohs(saddr->sin_port));
++            break;
++        case SOCKET_ADDRESS_TYPE_FD:
++            qemu_set_info_str(&s->nc, "fd=%d (cloned mcast=%s:%d)",
++                              fd, inet_ntoa(saddr->sin_addr),
++                              ntohs(saddr->sin_port));
++            break;
++        default:
++            g_assert_not_reached();
++        }
++    }
+     return 0;
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+         return -1;
+     }
+-    s = net_dgram_fd_init(peer, "dgram", name, fd, 0, NULL, errp);
++    s = net_dgram_fd_init(peer, "dgram", name, fd, errp);
+     if (!s) {
+         return -1;
+     }
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+                           inet_ntoa(raddr_in.sin_addr),
+                           ntohs(raddr_in.sin_port));
+         break;
+-    case SOCKET_ADDRESS_TYPE_FD:
+-        qemu_set_info_str(&s->nc, "fd=%d", fd);
++    case SOCKET_ADDRESS_TYPE_FD: {
++        SocketAddress *sa;
++        SocketAddressType sa_type;
++
++        sa = socket_local_address(fd, errp);
++        if (sa) {
++            sa_type = sa->type;
++            qapi_free_SocketAddress(sa);
++
++            qemu_set_info_str(&s->nc, "fd=%d %s", fd,
++                              SocketAddressType_str(sa_type));
++        } else {
++            qemu_set_info_str(&s->nc, "fd=%d", fd);
++        }
+         break;
++    }
+     default:
+         g_assert_not_reached();
+     }
+--
+.7.4

-New patch
+[PULL 22/26] net: dgram: add unix socket
+From: Laurent Vivier <lvivier@redhat.com>
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com> (QAPI schema)
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/dgram.c     | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
+ qapi/net.json   |  2 +-
+ qemu-options.hx |  1 +
+files changed, 56 insertions(+), 2 deletions(-)
+diff --git a/net/dgram.c b/net/dgram.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/dgram.c
++++ b/net/dgram.c
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+     SocketAddress *remote, *local;
+     struct sockaddr *dest_addr;
+     struct sockaddr_in laddr_in, raddr_in;
++    struct sockaddr_un laddr_un, raddr_un;
+     socklen_t dest_len;
+     assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+         }
+     } else {
+         if (local->type != SOCKET_ADDRESS_TYPE_FD) {
+-            error_setg(errp, "type=inet requires remote parameter");
++            error_setg(errp,
++                       "type=inet or type=unix requires remote parameter");
+             return -1;
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+         dest_addr = g_malloc(dest_len);
+         memcpy(dest_addr, &raddr_in, dest_len);
+         break;
++    case SOCKET_ADDRESS_TYPE_UNIX:
++        ret = unlink(local->u.q_unix.path);
++        if (ret < 0 && errno != ENOENT) {
++            error_setg_errno(errp, errno, "failed to unlink socket %s",
++                             local->u.q_unix.path);
++            return -1;
++        }
++
++        laddr_un.sun_family = PF_UNIX;
++        ret = snprintf(laddr_un.sun_path, sizeof(laddr_un.sun_path), "%s",
++                       local->u.q_unix.path);
++        if (ret < 0 || ret >= sizeof(laddr_un.sun_path)) {
++            error_setg(errp, "UNIX socket path '%s' is too long",
++                       local->u.q_unix.path);
++            error_append_hint(errp, "Path must be less than %zu bytes\n",
++                              sizeof(laddr_un.sun_path));
++        }
++
++        raddr_un.sun_family = PF_UNIX;
++        ret = snprintf(raddr_un.sun_path, sizeof(raddr_un.sun_path), "%s",
++                       remote->u.q_unix.path);
++        if (ret < 0 || ret >= sizeof(raddr_un.sun_path)) {
++            error_setg(errp, "UNIX socket path '%s' is too long",
++                       remote->u.q_unix.path);
++            error_append_hint(errp, "Path must be less than %zu bytes\n",
++                              sizeof(raddr_un.sun_path));
++        }
++
++        fd = qemu_socket(PF_UNIX, SOCK_DGRAM, 0);
++        if (fd < 0) {
++            error_setg_errno(errp, errno, "can't create datagram socket");
++            return -1;
++        }
++
++        ret = bind(fd, (struct sockaddr *)&laddr_un, sizeof(laddr_un));
++        if (ret < 0) {
++            error_setg_errno(errp, errno, "can't bind unix=%s to socket",
++                             laddr_un.sun_path);
++            closesocket(fd);
++            return -1;
++        }
++        qemu_socket_set_nonblock(fd);
++
++        dest_len = sizeof(raddr_un);
++        dest_addr = g_malloc(dest_len);
++        memcpy(dest_addr, &raddr_un, dest_len);
++        break;
+     case SOCKET_ADDRESS_TYPE_FD:
+         fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
+         if (fd == -1) {
+@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
+                           inet_ntoa(raddr_in.sin_addr),
+                           ntohs(raddr_in.sin_port));
+         break;
++    case SOCKET_ADDRESS_TYPE_UNIX:
++        qemu_set_info_str(&s->nc, "udp=%s:%s",
++                          laddr_un.sun_path, raddr_un.sun_path);
++        break;
+     case SOCKET_ADDRESS_TYPE_FD: {
+         SocketAddress *sa;
+         SocketAddressType sa_type;
+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 @@
+ # @remote: remote address
+ # @local: local address
+ #
+-# Only SocketAddress types 'inet' and 'fd' are supported.
++# Only SocketAddress types 'unix', 'inet' and 'fd' are supported.
+ #
+ # If remote address is present and it's a multicast address, local address
+ # is optional. Otherwise local address is required and remote address is
+diff --git a/qemu-options.hx b/qemu-options.hx
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-options.hx
++++ b/qemu-options.hx
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
+     "                configure a network backend to connect to a multicast maddr and port\n"
+     "                use ``local.host=addr`` to specify the host address to send packets from\n"
+     "-netdev dgram,id=str,local.type=inet,local.host=addr,local.port=port[,remote.type=inet,remote.host=addr,remote.port=port]\n"
++    "-netdev dgram,id=str,local.type=unix,local.path=path[,remote.type=unix,remote.path=path]\n"
+     "-netdev dgram,id=str,local.type=fd,local.str=file-descriptor\n"
+     "                configure a network backend to connect to another network\n"
+     "                using an UDP tunnel\n"
+--
+.7.4

-New patch
+[PULL 23/26] qemu-sockets: move and rename SocketAddress_to_str()
+From: Laurent Vivier <lvivier@redhat.com>
+Rename SocketAddress_to_str() to socket_uri() and move it to
+util/qemu-sockets.c close to socket_parse().
+socket_uri() generates a string from a SocketAddress while
+socket_parse() generates a SocketAddress from a string.
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ include/qemu/sockets.h |  2 +-
+ monitor/hmp-cmds.c     | 23 +----------------------
+ util/qemu-sockets.c    | 20 ++++++++++++++++++++
+files changed, 22 insertions(+), 23 deletions(-)
+diff --git a/include/qemu/sockets.h b/include/qemu/sockets.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/qemu/sockets.h
++++ b/include/qemu/sockets.h
+@@ -XXX,XX +XXX,XX @@ NetworkAddressFamily inet_netfamily(int family);
+ int unix_listen(const char *path, Error **errp);
+ int unix_connect(const char *path, Error **errp);
++char *socket_uri(SocketAddress *addr);
+ SocketAddress *socket_parse(const char *str, Error **errp);
+ int socket_connect(SocketAddress *addr, Error **errp);
+ int socket_listen(SocketAddress *addr, int num, Error **errp);
+@@ -XXX,XX +XXX,XX @@ SocketAddress *socket_address_flatten(SocketAddressLegacy *addr);
+  * Return 0 on success.
+  */
+ int socket_address_parse_named_fd(SocketAddress *addr, Error **errp);
+-
+ #endif /* QEMU_SOCKETS_H */
+diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/monitor/hmp-cmds.c
++++ b/monitor/hmp-cmds.c
+@@ -XXX,XX +XXX,XX @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
+     qapi_free_MouseInfoList(mice_list);
+ }
+-static char *SocketAddress_to_str(SocketAddress *addr)
+-{
+-    switch (addr->type) {
+-    case SOCKET_ADDRESS_TYPE_INET:
+-        return g_strdup_printf("tcp:%s:%s",
+-                               addr->u.inet.host,
+-                               addr->u.inet.port);
+-    case SOCKET_ADDRESS_TYPE_UNIX:
+-        return g_strdup_printf("unix:%s",
+-                               addr->u.q_unix.path);
+-    case SOCKET_ADDRESS_TYPE_FD:
+-        return g_strdup_printf("fd:%s", addr->u.fd.str);
+-    case SOCKET_ADDRESS_TYPE_VSOCK:
+-        return g_strdup_printf("tcp:%s:%s",
+-                               addr->u.vsock.cid,
+-                               addr->u.vsock.port);
+-    default:
+-        return g_strdup("unknown address type");
+-    }
+-}
+-
+ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
+ {
+     MigrationInfo *info;
+@@ -XXX,XX +XXX,XX @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
+         monitor_printf(mon, "socket address: [\n");
+         for (addr = info->socket_address; addr; addr = addr->next) {
+-            char *s = SocketAddress_to_str(addr->value);
++            char *s = socket_uri(addr->value);
+             monitor_printf(mon, "\t%s\n", s);
+             g_free(s);
+         }
+diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/qemu-sockets.c
++++ b/util/qemu-sockets.c
+@@ -XXX,XX +XXX,XX @@ int unix_connect(const char *path, Error **errp)
+     return sock;
+ }
++char *socket_uri(SocketAddress *addr)
++{
++    switch (addr->type) {
++    case SOCKET_ADDRESS_TYPE_INET:
++        return g_strdup_printf("tcp:%s:%s",
++                               addr->u.inet.host,
++                               addr->u.inet.port);
++    case SOCKET_ADDRESS_TYPE_UNIX:
++        return g_strdup_printf("unix:%s",
++                               addr->u.q_unix.path);
++    case SOCKET_ADDRESS_TYPE_FD:
++        return g_strdup_printf("fd:%s", addr->u.fd.str);
++    case SOCKET_ADDRESS_TYPE_VSOCK:
++        return g_strdup_printf("tcp:%s:%s",
++                               addr->u.vsock.cid,
++                               addr->u.vsock.port);
++    default:
++        return g_strdup("unknown address type");
++    }
++}
+ SocketAddress *socket_parse(const char *str, Error **errp)
+ {
+--
+.7.4

-New patch
+[PULL 24/26] qemu-sockets: update socket_uri() and socket_parse() to be consistent
+From: Laurent Vivier <lvivier@redhat.com>
+To be consistent with socket_uri(), add 'tcp:' prefix for inet type in
+socket_parse(), by default socket_parse() use tcp when no prefix is
+provided (format is host:port).
+In socket_uri(), use 'vsock:' prefix for vsock type rather than 'tcp:'
+because it makes a vsock address look like an inet address with CID
+misinterpreted as host.
+Goes back to commit 9aca82ba31 "migration: Create socket-address parameter"
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ util/qemu-sockets.c | 7 ++++++-
+file changed, 6 insertions(+), 1 deletion(-)
+diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/qemu-sockets.c
++++ b/util/qemu-sockets.c
+@@ -XXX,XX +XXX,XX @@ char *socket_uri(SocketAddress *addr)
+     case SOCKET_ADDRESS_TYPE_FD:
+         return g_strdup_printf("fd:%s", addr->u.fd.str);
+     case SOCKET_ADDRESS_TYPE_VSOCK:
+-        return g_strdup_printf("tcp:%s:%s",
++        return g_strdup_printf("vsock:%s:%s",
+                                addr->u.vsock.cid,
+                                addr->u.vsock.port);
+     default:
+@@ -XXX,XX +XXX,XX @@ SocketAddress *socket_parse(const char *str, Error **errp)
+         if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) {
+             goto fail;
+         }
++    } else if (strstart(str, "tcp:", NULL)) {
++        addr->type = SOCKET_ADDRESS_TYPE_INET;
++        if (inet_parse(&addr->u.inet, str + strlen("tcp:"), errp)) {
++            goto fail;
++        }
+     } else {
+         addr->type = SOCKET_ADDRESS_TYPE_INET;
+         if (inet_parse(&addr->u.inet, str, errp)) {
+--
+.7.4

-New patch
+[PULL 25/26] net: stream: move to QIO to enable additional parameters
+From: Laurent Vivier <lvivier@redhat.com>
+Use QIOChannel, QIOChannelSocket and QIONetListener.
+This allows net/stream to use all the available parameters provided by
+SocketAddress.
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/stream.c    | 492 ++++++++++++++++++++------------------------------------
+ qemu-options.hx |   4 +-
+files changed, 178 insertions(+), 318 deletions(-)
+diff --git a/net/stream.c b/net/stream.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/stream.c
++++ b/net/stream.c
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/iov.h"
+ #include "qemu/main-loop.h"
+ #include "qemu/cutils.h"
++#include "io/channel.h"
++#include "io/channel-socket.h"
++#include "io/net-listener.h"
+ typedef struct NetStreamState {
+     NetClientState nc;
+-    int listen_fd;
+-    int fd;
++    QIOChannel *listen_ioc;
++    QIONetListener *listener;
++    QIOChannel *ioc;
++    guint ioc_read_tag;
++    guint ioc_write_tag;
+     SocketReadState rs;
+     unsigned int send_index;      /* number of bytes sent*/
+-    bool read_poll;               /* waiting to receive data? */
+-    bool write_poll;              /* waiting to transmit data? */
+ } NetStreamState;
+-static void net_stream_send(void *opaque);
+-static void net_stream_accept(void *opaque);
+-static void net_stream_writable(void *opaque);
++static void net_stream_listen(QIONetListener *listener,
++                              QIOChannelSocket *cioc,
++                              void *opaque);
+-static void net_stream_update_fd_handler(NetStreamState *s)
++static gboolean net_stream_writable(QIOChannel *ioc,
++                                    GIOCondition condition,
++                                    gpointer data)
+ {
+-    qemu_set_fd_handler(s->fd,
+-                        s->read_poll ? net_stream_send : NULL,
+-                        s->write_poll ? net_stream_writable : NULL,
+-                        s);
+-}
+-
+-static void net_stream_read_poll(NetStreamState *s, bool enable)
+-{
+-    s->read_poll = enable;
+-    net_stream_update_fd_handler(s);
+-}
+-
+-static void net_stream_write_poll(NetStreamState *s, bool enable)
+-{
+-    s->write_poll = enable;
+-    net_stream_update_fd_handler(s);
+-}
+-
+-static void net_stream_writable(void *opaque)
+-{
+-    NetStreamState *s = opaque;
++    NetStreamState *s = data;
+-    net_stream_write_poll(s, false);
++    s->ioc_write_tag = 0;
+     qemu_flush_queued_packets(&s->nc);
++
++    return G_SOURCE_REMOVE;
+ }
+ static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
+@@ -XXX,XX +XXX,XX @@ static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
+             .iov_len  = size,
+         },
+     };
++    struct iovec local_iov[2];
++    unsigned int nlocal_iov;
+     size_t remaining;
+     ssize_t ret;
+     remaining = iov_size(iov, 2) - s->send_index;
+-    ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
+-
+-    if (ret == -1 && errno == EAGAIN) {
++    nlocal_iov = iov_copy(local_iov, 2, iov, 2, s->send_index, remaining);
++    ret = qio_channel_writev(s->ioc, local_iov, nlocal_iov, NULL);
++    if (ret == QIO_CHANNEL_ERR_BLOCK) {
+         ret = 0; /* handled further down */
+     }
+     if (ret == -1) {
+@@ -XXX,XX +XXX,XX @@ static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
+     }
+     if (ret < (ssize_t)remaining) {
+         s->send_index += ret;
+-        net_stream_write_poll(s, true);
++        s->ioc_write_tag = qio_channel_add_watch(s->ioc, G_IO_OUT,
++                                                 net_stream_writable, s, NULL);
+         return 0;
+     }
+     s->send_index = 0;
+     return size;
+ }
++static gboolean net_stream_send(QIOChannel *ioc,
++                                GIOCondition condition,
++                                gpointer data);
++
+ static void net_stream_send_completed(NetClientState *nc, ssize_t len)
+ {
+     NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
+-    if (!s->read_poll) {
+-        net_stream_read_poll(s, true);
++    if (!s->ioc_read_tag) {
++        s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN,
++                                                net_stream_send, s, NULL);
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ static void net_stream_rs_finalize(SocketReadState *rs)
+     if (qemu_send_packet_async(&s->nc, rs->buf,
+                                rs->packet_len,
+                                net_stream_send_completed) == 0) {
+-        net_stream_read_poll(s, false);
++        if (s->ioc_read_tag) {
++            g_source_remove(s->ioc_read_tag);
++            s->ioc_read_tag = 0;
++        }
+     }
+ }
+-static void net_stream_send(void *opaque)
++static gboolean net_stream_send(QIOChannel *ioc,
++                                GIOCondition condition,
++                                gpointer data)
+ {
+-    NetStreamState *s = opaque;
++    NetStreamState *s = data;
+     int size;
+     int ret;
+-    uint8_t buf1[NET_BUFSIZE];
+-    const uint8_t *buf;
++    char buf1[NET_BUFSIZE];
++    const char *buf;
+-    size = recv(s->fd, buf1, sizeof(buf1), 0);
++    size = qio_channel_read(s->ioc, buf1, sizeof(buf1), NULL);
+     if (size < 0) {
+         if (errno != EWOULDBLOCK) {
+             goto eoc;
+@@ -XXX,XX +XXX,XX @@ static void net_stream_send(void *opaque)
+     } else if (size == 0) {
+         /* end of connection */
+     eoc:
+-        net_stream_read_poll(s, false);
+-        net_stream_write_poll(s, false);
+-        if (s->listen_fd != -1) {
+-            qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
++        s->ioc_read_tag = 0;
++        if (s->ioc_write_tag) {
++            g_source_remove(s->ioc_write_tag);
++            s->ioc_write_tag = 0;
+         }
+-        closesocket(s->fd);
++        if (s->listener) {
++            qio_net_listener_set_client_func(s->listener, net_stream_listen,
++                                             s, NULL);
++        }
++        object_unref(OBJECT(s->ioc));
++        s->ioc = NULL;
+-        s->fd = -1;
+         net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+         s->nc.link_down = true;
+         qemu_set_info_str(&s->nc, "");
+-        return;
++        return G_SOURCE_REMOVE;
+     }
+     buf = buf1;
+-    ret = net_fill_rstate(&s->rs, buf, size);
++    ret = net_fill_rstate(&s->rs, (const uint8_t *)buf, size);
+     if (ret == -1) {
+         goto eoc;
+     }
++
++    return G_SOURCE_CONTINUE;
+ }
+ static void net_stream_cleanup(NetClientState *nc)
+ {
+     NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
+-    if (s->fd != -1) {
+-        net_stream_read_poll(s, false);
+-        net_stream_write_poll(s, false);
+-        close(s->fd);
+-        s->fd = -1;
++    if (s->ioc) {
++        if (QIO_CHANNEL_SOCKET(s->ioc)->fd != -1) {
++            if (s->ioc_read_tag) {
++                g_source_remove(s->ioc_read_tag);
++                s->ioc_read_tag = 0;
++            }
++            if (s->ioc_write_tag) {
++                g_source_remove(s->ioc_write_tag);
++                s->ioc_write_tag = 0;
++            }
++        }
++        object_unref(OBJECT(s->ioc));
++        s->ioc = NULL;
+     }
+-    if (s->listen_fd != -1) {
+-        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
+-        closesocket(s->listen_fd);
+-        s->listen_fd = -1;
++    if (s->listen_ioc) {
++        if (s->listener) {
++            qio_net_listener_disconnect(s->listener);
++            object_unref(OBJECT(s->listener));
++            s->listener = NULL;
++        }
++        object_unref(OBJECT(s->listen_ioc));
++        s->listen_ioc = NULL;
+     }
+ }
+-static void net_stream_connect(void *opaque)
+-{
+-    NetStreamState *s = opaque;
+-    net_stream_read_poll(s, true);
+-}
+-
+ static NetClientInfo net_stream_info = {
+     .type = NET_CLIENT_DRIVER_STREAM,
+     .size = sizeof(NetStreamState),
+@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_stream_info = {
+     .cleanup = net_stream_cleanup,
+ };
+-static NetStreamState *net_stream_fd_init(NetClientState *peer,
+-                                          const char *model,
+-                                          const char *name,
+-                                          int fd, int is_connected)
++static void net_stream_listen(QIONetListener *listener,
++                              QIOChannelSocket *cioc,
++                              void *opaque)
+ {
+-    NetClientState *nc;
+-    NetStreamState *s;
+-
+-    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
++    NetStreamState *s = opaque;
++    SocketAddress *addr;
++    char *uri;
+-    qemu_set_info_str(nc, "fd=%d", fd);
++    object_ref(OBJECT(cioc));
+-    s = DO_UPCAST(NetStreamState, nc, nc);
++    qio_net_listener_set_client_func(s->listener, NULL, s, NULL);
+-    s->fd = fd;
+-    s->listen_fd = -1;
+-    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
++    s->ioc = QIO_CHANNEL(cioc);
++    qio_channel_set_name(s->ioc, "stream-server");
++    s->nc.link_down = false;
+-    /* Disable Nagle algorithm on TCP sockets to reduce latency */
+-    socket_set_nodelay(fd);
++    s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
++                                            s, NULL);
+-    if (is_connected) {
+-        net_stream_connect(s);
++    if (cioc->localAddr.ss_family == AF_UNIX) {
++        addr = qio_channel_socket_get_local_address(cioc, NULL);
+     } else {
+-        qemu_set_fd_handler(s->fd, NULL, net_stream_connect, s);
++        addr = qio_channel_socket_get_remote_address(cioc, NULL);
+     }
+-    return s;
++    g_assert(addr != NULL);
++    uri = socket_uri(addr);
++    qemu_set_info_str(&s->nc, uri);
++    g_free(uri);
++    qapi_free_SocketAddress(addr);
+ }
+-static void net_stream_accept(void *opaque)
++static void net_stream_server_listening(QIOTask *task, gpointer opaque)
+ {
+     NetStreamState *s = opaque;
+-    struct sockaddr_storage saddr;
+-    socklen_t len;
+-    int fd;
+-
+-    for (;;) {
+-        len = sizeof(saddr);
+-        fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
+-        if (fd < 0 && errno != EINTR) {
+-            return;
+-        } else if (fd >= 0) {
+-            qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
+-            break;
+-        }
+-    }
++    QIOChannelSocket *listen_sioc = QIO_CHANNEL_SOCKET(s->listen_ioc);
++    SocketAddress *addr;
++    int ret;
+-    s->fd = fd;
+-    s->nc.link_down = false;
+-    net_stream_connect(s);
+-    switch (saddr.ss_family) {
+-    case AF_INET: {
+-        struct sockaddr_in *saddr_in = (struct sockaddr_in *)&saddr;
+-
+-        qemu_set_info_str(&s->nc, "connection from %s:%d",
+-                          inet_ntoa(saddr_in->sin_addr),
+-                          ntohs(saddr_in->sin_port));
+-        break;
++    if (listen_sioc->fd < 0) {
++        qemu_set_info_str(&s->nc, "connection error");
++        return;
+     }
+-    case AF_UNIX: {
+-        struct sockaddr_un saddr_un;
+-        len = sizeof(saddr_un);
+-        getsockname(s->listen_fd, (struct sockaddr *)&saddr_un, &len);
+-        qemu_set_info_str(&s->nc, "connect from %s", saddr_un.sun_path);
+-        break;
+-    }
+-    default:
+-        g_assert_not_reached();
++    addr = qio_channel_socket_get_local_address(listen_sioc, NULL);
++    g_assert(addr != NULL);
++    ret = qemu_socket_try_set_nonblock(listen_sioc->fd);
++    if (addr->type == SOCKET_ADDRESS_TYPE_FD && ret < 0) {
++        qemu_set_info_str(&s->nc, "can't use file descriptor %s (errno %d)",
++                          addr->u.fd.str, -ret);
++        return;
+     }
++    g_assert(ret == 0);
++    qapi_free_SocketAddress(addr);
++
++    s->nc.link_down = true;
++    s->listener = qio_net_listener_new();
++
++    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
++    qio_net_listener_set_client_func(s->listener, net_stream_listen, s, NULL);
++    qio_net_listener_add(s->listener, listen_sioc);
+ }
+ static int net_stream_server_init(NetClientState *peer,
+@@ -XXX,XX +XXX,XX @@ static int net_stream_server_init(NetClientState *peer,
+ {
+     NetClientState *nc;
+     NetStreamState *s;
+-    int fd, ret;
++    QIOChannelSocket *listen_sioc = qio_channel_socket_new();
+-    switch (addr->type) {
+-    case SOCKET_ADDRESS_TYPE_INET: {
+-        struct sockaddr_in saddr_in;
+-
+-        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
+-                              errp) < 0) {
+-            return -1;
+-        }
+-
+-        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
+-        if (fd < 0) {
+-            error_setg_errno(errp, errno, "can't create stream socket");
+-            return -1;
+-        }
+-        qemu_socket_set_nonblock(fd);
++    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
++    s = DO_UPCAST(NetStreamState, nc, nc);
+-        socket_set_fast_reuse(fd);
++    s->listen_ioc = QIO_CHANNEL(listen_sioc);
++    qio_channel_socket_listen_async(listen_sioc, addr, 0,
++                                    net_stream_server_listening, s,
++                                    NULL, NULL);
+-        ret = bind(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
+-        if (ret < 0) {
+-            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
+-                             inet_ntoa(saddr_in.sin_addr));
+-            closesocket(fd);
+-            return -1;
+-        }
+-        break;
+-    }
+-    case SOCKET_ADDRESS_TYPE_UNIX: {
+-        struct sockaddr_un saddr_un;
+-
+-        ret = unlink(addr->u.q_unix.path);
+-        if (ret < 0 && errno != ENOENT) {
+-            error_setg_errno(errp, errno, "failed to unlink socket %s",
+-                             addr->u.q_unix.path);
+-            return -1;
+-        }
++    return 0;
++}
+-        saddr_un.sun_family = PF_UNIX;
+-        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
+-                       addr->u.q_unix.path);
+-        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
+-            error_setg(errp, "UNIX socket path '%s' is too long",
+-                       addr->u.q_unix.path);
+-            error_append_hint(errp, "Path must be less than %zu bytes\n",
+-                              sizeof(saddr_un.sun_path));
+-            return -1;
+-        }
++static void net_stream_client_connected(QIOTask *task, gpointer opaque)
++{
++    NetStreamState *s = opaque;
++    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(s->ioc);
++    SocketAddress *addr;
++    gchar *uri;
++    int ret;
+-        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
+-        if (fd < 0) {
+-            error_setg_errno(errp, errno, "can't create stream socket");
+-            return -1;
+-        }
+-        qemu_socket_set_nonblock(fd);
+-
+-        ret = bind(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
+-        if (ret < 0) {
+-            error_setg_errno(errp, errno, "can't create socket with path: %s",
+-                             saddr_un.sun_path);
+-            closesocket(fd);
+-            return -1;
+-        }
+-        break;
+-    }
+-    case SOCKET_ADDRESS_TYPE_FD:
+-        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
+-        if (fd == -1) {
+-            return -1;
+-        }
+-        ret = qemu_socket_try_set_nonblock(fd);
+-        if (ret < 0) {
+-            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+-                             name, fd);
+-            return -1;
+-        }
+-        break;
+-    default:
+-        error_setg(errp, "only support inet or fd type");
+-        return -1;
++    if (sioc->fd < 0) {
++        qemu_set_info_str(&s->nc, "connection error");
++        goto error;
+     }
+-    ret = listen(fd, 0);
+-    if (ret < 0) {
+-        error_setg_errno(errp, errno, "can't listen on socket");
+-        closesocket(fd);
+-        return -1;
++    addr = qio_channel_socket_get_remote_address(sioc, NULL);
++    g_assert(addr != NULL);
++    uri = socket_uri(addr);
++    qemu_set_info_str(&s->nc, uri);
++    g_free(uri);
++
++    ret = qemu_socket_try_set_nonblock(sioc->fd);
++    if (addr->type == SOCKET_ADDRESS_TYPE_FD && ret < 0) {
++        qemu_set_info_str(&s->nc, "can't use file descriptor %s (errno %d)",
++                          addr->u.fd.str, -ret);
++        qapi_free_SocketAddress(addr);
++        goto error;
+     }
++    g_assert(ret == 0);
+-    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+-    s = DO_UPCAST(NetStreamState, nc, nc);
+-    s->fd = -1;
+-    s->listen_fd = fd;
+-    s->nc.link_down = true;
+     net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+-    qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
+-    return 0;
++    /* Disable Nagle algorithm on TCP sockets to reduce latency */
++    qio_channel_set_delay(s->ioc, false);
++
++    s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
++                                            s, NULL);
++    s->nc.link_down = false;
++    qapi_free_SocketAddress(addr);
++
++    return;
++error:
++    object_unref(OBJECT(s->ioc));
++    s->ioc = NULL;
+ }
+ static int net_stream_client_init(NetClientState *peer,
+@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
+                                   Error **errp)
+ {
+     NetStreamState *s;
+-    struct sockaddr_in saddr_in;
+-    struct sockaddr_un saddr_un;
+-    int fd, connected, ret;
+-
+-    switch (addr->type) {
+-    case SOCKET_ADDRESS_TYPE_INET:
+-        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
+-                              errp) < 0) {
+-            return -1;
+-        }
++    NetClientState *nc;
++    QIOChannelSocket *sioc = qio_channel_socket_new();
+-        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
+-        if (fd < 0) {
+-            error_setg_errno(errp, errno, "can't create stream socket");
+-            return -1;
+-        }
+-        qemu_socket_set_nonblock(fd);
+-
+-        connected = 0;
+-        for (;;) {
+-            ret = connect(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
+-            if (ret < 0) {
+-                if (errno == EINTR || errno == EWOULDBLOCK) {
+-                    /* continue */
+-                } else if (errno == EINPROGRESS ||
+-                           errno == EALREADY) {
+-                    break;
+-                } else {
+-                    error_setg_errno(errp, errno, "can't connect socket");
+-                    closesocket(fd);
+-                    return -1;
+-                }
+-            } else {
+-                connected = 1;
+-                break;
+-            }
+-        }
+-        break;
+-    case SOCKET_ADDRESS_TYPE_UNIX:
+-        saddr_un.sun_family = PF_UNIX;
+-        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
+-                       addr->u.q_unix.path);
+-        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
+-            error_setg(errp, "UNIX socket path '%s' is too long",
+-                       addr->u.q_unix.path);
+-            error_append_hint(errp, "Path must be less than %zu bytes\n",
+-                              sizeof(saddr_un.sun_path));
+-            return -1;
+-        }
++    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
++    s = DO_UPCAST(NetStreamState, nc, nc);
+-        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
+-        if (fd < 0) {
+-            error_setg_errno(errp, errno, "can't create stream socket");
+-            return -1;
+-        }
+-        qemu_socket_set_nonblock(fd);
+-
+-        connected = 0;
+-        for (;;) {
+-            ret = connect(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
+-            if (ret < 0) {
+-                if (errno == EINTR || errno == EWOULDBLOCK) {
+-                    /* continue */
+-                } else if (errno == EAGAIN ||
+-                           errno == EALREADY) {
+-                    break;
+-                } else {
+-                    error_setg_errno(errp, errno, "can't connect socket");
+-                    closesocket(fd);
+-                    return -1;
+-                }
+-            } else {
+-                connected = 1;
+-                break;
+-            }
+-        }
+-        break;
+-    case SOCKET_ADDRESS_TYPE_FD:
+-        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
+-        if (fd == -1) {
+-            return -1;
+-        }
+-        ret = qemu_socket_try_set_nonblock(fd);
+-        if (ret < 0) {
+-            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+-                             name, fd);
+-            return -1;
+-        }
+-        connected = 1;
+-        break;
+-    default:
+-        error_setg(errp, "only support inet, unix or fd type");
+-        return -1;
+-    }
++    s->ioc = QIO_CHANNEL(sioc);
++    s->nc.link_down = true;
++
++    qio_channel_socket_connect_async(sioc, addr,
++                                     net_stream_client_connected, s,
++                                     NULL, NULL);
+-    s = net_stream_fd_init(peer, model, name, fd, connected);
+-
+-    switch (addr->type) {
+-    case SOCKET_ADDRESS_TYPE_INET:
+-        qemu_set_info_str(&s->nc, "connect to %s:%d",
+-                          inet_ntoa(saddr_in.sin_addr),
+-                          ntohs(saddr_in.sin_port));
+-        break;
+-    case SOCKET_ADDRESS_TYPE_UNIX:
+-        qemu_set_info_str(&s->nc, " connect to %s", saddr_un.sun_path);
+-        break;
+-    case SOCKET_ADDRESS_TYPE_FD:
+-        qemu_set_info_str(&s->nc, "connect to fd %d", fd);
+-        break;
+-    default:
+-        g_assert_not_reached();
+-    }
+     return 0;
+ }
+diff --git a/qemu-options.hx b/qemu-options.hx
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-options.hx
++++ b/qemu-options.hx
+@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
+     "-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"
+     "                configure a network backend to connect to another network\n"
+     "                using an UDP tunnel\n"
+-    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
+-    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path\n"
++    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port[,to=maxport][,numeric=on|off][,keep-alive=on|off][,mptcp=on|off][,addr.ipv4=on|off][,addr.ipv6=on|off]\n"
++    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path[,abstract=on|off][,tight=on|off]\n"
+     "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
+     "                configure a network backend to connect to another network\n"
+     "                using a socket connection in stream mode.\n"
+--
+.7.4

-New patch
+[PULL 26/26] net: stream: add QAPI events to report connection state
+From: Laurent Vivier <lvivier@redhat.com>
+The netdev reports NETDEV_STREAM_CONNECTED event when the backend
+is connected, and NETDEV_STREAM_DISCONNECTED when it is disconnected.
+The NETDEV_STREAM_CONNECTED event includes the destination address.
+This allows a system manager like libvirt to detect when the server
+fails.
+For instance with passt:
+{ 'execute': 'qmp_capabilities' }
+{ "return": { } }
+{ "timestamp": { "seconds": 1666341395, "microseconds": 505347 },
+    "event": "NETDEV_STREAM_CONNECTED",
+    "data": { "netdev-id": "netdev0",
+        "addr": { "path": "/tmp/passt_1.socket", "type": "unix" } } }
+[killing passt here]
+{ "timestamp": { "seconds": 1666341430, "microseconds": 968694 },
+    "event": "NETDEV_STREAM_DISCONNECTED",
+    "data": { "netdev-id": "netdev0" } }
+Signed-off-by: Laurent Vivier <lvivier@redhat.com>
+Acked-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/stream.c  |  5 +++++
+ qapi/net.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
+files changed, 54 insertions(+)
+diff --git a/net/stream.c b/net/stream.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/stream.c
++++ b/net/stream.c
+@@ -XXX,XX +XXX,XX @@
+ #include "io/channel.h"
+ #include "io/channel-socket.h"
+ #include "io/net-listener.h"
++#include "qapi/qapi-events-net.h"
+ typedef struct NetStreamState {
+     NetClientState nc;
+@@ -XXX,XX +XXX,XX @@ static gboolean net_stream_send(QIOChannel *ioc,
+         s->nc.link_down = true;
+         qemu_set_info_str(&s->nc, "");
++        qapi_event_send_netdev_stream_disconnected(s->nc.name);
++
+         return G_SOURCE_REMOVE;
+     }
+     buf = buf1;
+@@ -XXX,XX +XXX,XX @@ static void net_stream_listen(QIONetListener *listener,
+     uri = socket_uri(addr);
+     qemu_set_info_str(&s->nc, uri);
+     g_free(uri);
++    qapi_event_send_netdev_stream_connected(s->nc.name, addr);
+     qapi_free_SocketAddress(addr);
+ }
+@@ -XXX,XX +XXX,XX @@ static void net_stream_client_connected(QIOTask *task, gpointer opaque)
+     s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
+                                             s, NULL);
+     s->nc.link_down = false;
++    qapi_event_send_netdev_stream_connected(s->nc.name, addr);
+     qapi_free_SocketAddress(addr);
+     return;
+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': 'FAILOVER_NEGOTIATED',
+   'data': {'device-id': 'str'} }
++
++##
++# @NETDEV_STREAM_CONNECTED:
++#
++# Emitted when the netdev stream backend is connected
++#
++# @netdev-id: QEMU netdev id that is connected
++# @addr: The destination address
++#
++# Since: 7.2
++#
++# Example:
++#
++# <- { "event": "NETDEV_STREAM_CONNECTED",
++#      "data": { "netdev-id": "netdev0",
++#                "addr": { "port": "47666", "ipv6": true,
++#                          "host": "::1", "type": "inet" } },
++#      "timestamp": { "seconds": 1666269863, "microseconds": 311222 } }
++#
++# or
++#
++# <- { "event": "NETDEV_STREAM_CONNECTED",
++#      "data": { "netdev-id": "netdev0",
++#                "addr": { "path": "/tmp/qemu0", "type": "unix" } },
++#      "timestamp": { "seconds": 1666269706, "microseconds": 413651 } }
++#
++##
++{ 'event': 'NETDEV_STREAM_CONNECTED',
++  'data': { 'netdev-id': 'str',
++            'addr': 'SocketAddress' } }
++
++##
++# @NETDEV_STREAM_DISCONNECTED:
++#
++# Emitted when the netdev stream backend is disconnected
++#
++# @netdev-id: QEMU netdev id that is disconnected
++#
++# Since: 7.2
++#
++# Example:
++#
++# <- { 'event': 'NETDEV_STREAM_DISCONNECTED',
++#      'data': {'netdev-id': 'netdev0'},
++#      'timestamp': {'seconds': 1663330937, 'microseconds': 526695} }
++#
++##
++{ 'event': 'NETDEV_STREAM_DISCONNECTED',
++  'data': { 'netdev-id': 'str' } }
+--
+.7.4

The following changes since commit e607bbee553cfe73072870cef458cfa4e78133e2:

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

are available in the git repository at:

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

for you to fetch changes up to bf4835a4d5338bb7424827715df22570a8adc67c:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

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

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

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

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

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

Same applies to the hostfwd_remove command now.

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

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

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

gently asked by his automatic reply :)

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

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

The following changes since commit 344744e148e6e865f5a57e745b02a87e5ea534ad:

Merge tag 'dump-pull-request' of https://gitlab.com/marcandre.lureau/qemu into staging (2022-10-26 10:53:49 -0400)

are available in the git repository at:

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

for you to fetch changes up to e506fee8b1e092f6ac6f9459bf6a35b807644ad2:

net: stream: add QAPI events to report connection state (2022-10-28 13:28:52 +0800)

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

----------------------------------------------------------------
Daniel P. Berrangé (1):
      net: improve error message for missing netdev backend

Eugenio Pérez (6):
      vdpa: Delete duplicated vdpa_feature_bits entry
      vdpa: Remove shadow CVQ command check
      vhost: allocate event_idx fields on vring
      vhost: toggle device callbacks using used event idx
      vhost: use avail event idx on vhost_svq_kick
      vhost: Accept event idx flag

Laurent Vivier (16):
      virtio-net: fix bottom-half packet TX on asynchronous completion
      virtio-net: fix TX timer with tx_burst
      net: introduce convert_host_port()
      net: remove the @errp argument of net_client_inits()
      net: simplify net_client_parse() error management
      qapi: net: introduce a way to bypass qemu_opts_parse_noisily()
      net: introduce qemu_set_info_str() function
      qapi: net: add stream and dgram netdevs
      net: stream: add unix socket
      net: dgram: make dgram_dst generic
      net: dgram: move mcast specific code from net_socket_fd_init_dgram()
      net: dgram: add unix socket
      qemu-sockets: move and rename SocketAddress_to_str()
      qemu-sockets: update socket_uri() and socket_parse() to be consistent
      net: stream: move to QIO to enable additional parameters
      net: stream: add QAPI events to report connection state

Si-Wei Liu (1):
      vhost-vdpa: allow passing opened vhostfd to vhost-vdpa

Stefano Brivio (2):
      net: socket: Don't ignore EINVAL on netdev socket connection
      net: stream: Don't ignore EINVAL on netdev socket connection

From: Laurent Vivier <lvivier@redhat.com>

When virtio-net is used with the socket netdev backend, the backend
can be busy and not able to collect new packets.

In this case, net_socket_receive() returns 0 and registers a poll function
to detect when the socket is ready again.

In virtio_net_tx_bh(), virtio_net_flush_tx() forwards the 0, the virtio
notifications are disabled and the function is not re-scheduled, waiting
for the backend to be ready.

When the socket netdev backend is again able to send packets, the poll
function re-starts to flush remaining packets. This is done by
calling virtio_net_tx_complete(). It re-enables notifications and calls
again virtio_net_flush_tx().

But it seems if virtio_net_flush_tx() reaches the tx_burst value all
the queue is not flushed and no new notification is sent to re-schedule
virtio_net_tx_bh(). Nothing re-start to flush the queue and remaining
packets are stuck in the queue.

To fix that, detect in virtio_net_tx_complete() if virtio_net_flush_tx()
has been stopped by tx_burst and if yes re-schedule the bottom half
function virtio_net_tx_bh() to flush the remaining packets.

This is what is done in virtio_net_tx_bh() when the virtio_net_flush_tx()
is synchronous, and completly by-passed when the operation needs to be
asynchronous.

Fixes: a697a334b3c4 ("virtio-net: Introduce a new bottom half packet TX")
Cc: alex.williamson@redhat.com
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/virtio-net.c | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

From: Laurent Vivier <lvivier@redhat.com>

When virtio_net_flush_tx() reaches the tx_burst value all
the queue is not flushed and nothing restart the timer.

Fix that by doing for TX timer as we do for bottom half TX:
rearming the timer if we find any packet to send during the
virtio_net_flush_tx() call.

Fixes: e3f30488e5f8 ("virtio-net: Limit number of packets sent per TX flush")
Cc: alex.williamson@redhat.com
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/virtio-net.c | 50 +++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 41 insertions(+), 9 deletions(-)

diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
 
     virtio_queue_set_notification(q->tx_vq, 1);
     ret = virtio_net_flush_tx(q);
-    if (q->tx_bh && ret >= n->tx_burst) {
+    if (ret >= n->tx_burst) {
         /*
          * the flush has been stopped by tx_burst
          * we will not receive notification for the
          * remainining part, so re-schedule
          */
         virtio_queue_set_notification(q->tx_vq, 0);
-        qemu_bh_schedule(q->tx_bh);
+        if (q->tx_bh) {
+            qemu_bh_schedule(q->tx_bh);
+        } else {
+            timer_mod(q->tx_timer,
+                      qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
+        }
         q->tx_waiting = 1;
     }
 }
@@ -XXX,XX +XXX,XX @@ drop:
     return num_packets;
 }
 
+static void virtio_net_tx_timer(void *opaque);
+
 static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
 {
     VirtIONet *n = VIRTIO_NET(vdev);
@@ -XXX,XX +XXX,XX @@ static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
     }
 
     if (q->tx_waiting) {
-        virtio_queue_set_notification(vq, 1);
+        /* We already have queued packets, immediately flush */
         timer_del(q->tx_timer);
-        q->tx_waiting = 0;
-        if (virtio_net_flush_tx(q) == -EINVAL) {
-            return;
-        }
+        virtio_net_tx_timer(q);
     } else {
+        /* re-arm timer to flush it (and more) on next tick */
         timer_mod(q->tx_timer,
-                       qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
+                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
         q->tx_waiting = 1;
         virtio_queue_set_notification(vq, 0);
     }
@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_timer(void *opaque)
     VirtIONetQueue *q = opaque;
     VirtIONet *n = q->n;
     VirtIODevice *vdev = VIRTIO_DEVICE(n);
+    int ret;
+
     /* This happens when device was stopped but BH wasn't. */
     if (!vdev->vm_running) {
         /* Make sure tx waiting is set, so we'll run when restarted. */
@@ -XXX,XX +XXX,XX @@ static void virtio_net_tx_timer(void *opaque)
         return;
     }
 
+    ret = virtio_net_flush_tx(q);
+    if (ret == -EBUSY || ret == -EINVAL) {
+        return;
+    }
+    /*
+     * If we flush a full burst of packets, assume there are
+     * more coming and immediately rearm
+     */
+    if (ret >= n->tx_burst) {
+        q->tx_waiting = 1;
+        timer_mod(q->tx_timer,
+                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
+        return;
+    }
+    /*
+     * If less than a full burst, re-enable notification and flush
+     * anything that may have come in while we weren't looking.  If
+     * we find something, assume the guest is still active and rearm
+     */
     virtio_queue_set_notification(q->tx_vq, 1);
-    virtio_net_flush_tx(q);
+    ret = virtio_net_flush_tx(q);
+    if (ret > 0) {
+        virtio_queue_set_notification(q->tx_vq, 0);
+        q->tx_waiting = 1;
+        timer_mod(q->tx_timer,
+                  qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
+    }
 }
 
 static void virtio_net_tx_bh(void *opaque)
-- 
2.7.4

From: Eugenio Pérez <eperezma@redhat.com>

The guest will see undefined behavior if it issue not negotiate
commands, bit it is expected somehow.

Simplify code deleting this check.

Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Acked-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/vhost-vdpa.c | 48 ------------------------------------------------
 1 file changed, 48 deletions(-)

diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vhost-vdpa.c
+++ b/net/vhost-vdpa.c
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_vhost_vdpa_cvq_info = {
 };
 
 /**
- * Do not forward commands not supported by SVQ. Otherwise, the device could
- * accept it and qemu would not know how to update the device model.
- */
-static bool vhost_vdpa_net_cvq_validate_cmd(const void *out_buf, size_t len)
-{
-    struct virtio_net_ctrl_hdr ctrl;
-
-    if (unlikely(len < sizeof(ctrl))) {
-        qemu_log_mask(LOG_GUEST_ERROR,
-                      "%s: invalid legnth of out buffer %zu\n", __func__, len);
-        return false;
-    }
-
-    memcpy(&ctrl, out_buf, sizeof(ctrl));
-    switch (ctrl.class) {
-    case VIRTIO_NET_CTRL_MAC:
-        switch (ctrl.cmd) {
-        case VIRTIO_NET_CTRL_MAC_ADDR_SET:
-            return true;
-        default:
-            qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid mac cmd %u\n",
-                          __func__, ctrl.cmd);
-        };
-        break;
-    case VIRTIO_NET_CTRL_MQ:
-        switch (ctrl.cmd) {
-        case VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET:
-            return true;
-        default:
-            qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid mq cmd %u\n",
-                          __func__, ctrl.cmd);
-        };
-        break;
-    default:
-        qemu_log_mask(LOG_GUEST_ERROR, "%s: invalid control class %u\n",
-                      __func__, ctrl.class);
-    };
-
-    return false;
-}
-
-/**
  * Validate and copy control virtqueue commands.
  *
  * Following QEMU guidelines, we offer a copy of the buffers to the device to
@@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_net_handle_ctrl_avail(VhostShadowVirtqueue *svq,
         .iov_len = sizeof(status),
     };
     ssize_t dev_written = -EINVAL;
-    bool ok;
 
     out.iov_len = iov_to_buf(elem->out_sg, elem->out_num, 0,
                              s->cvq_cmd_out_buffer,
                              vhost_vdpa_net_cvq_cmd_len());
-    ok = vhost_vdpa_net_cvq_validate_cmd(s->cvq_cmd_out_buffer, out.iov_len);
-    if (unlikely(!ok)) {
-        goto out;
-    }
-
     dev_written = vhost_vdpa_net_cvq_add(s, out.iov_len, sizeof(status));
     if (unlikely(dev_written < 0)) {
         goto out;
-- 
2.7.4

From: Si-Wei Liu <si-wei.liu@oracle.com>

Similar to other vhost backends, vhostfd can be passed to vhost-vdpa
backend as another parameter to instantiate vhost-vdpa net client.
This would benefit the use case where only open file descriptors, as
opposed to raw vhost-vdpa device paths, are accessible from the QEMU
process.

(qemu) netdev_add type=vhost-vdpa,vhostfd=61,id=vhost-vdpa1

Signed-off-by: Si-Wei Liu <si-wei.liu@oracle.com>
Acked-by: Eugenio Pérez <eperezma@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/vhost-vdpa.c | 25 ++++++++++++++++++++-----
 qapi/net.json    |  3 +++
 qemu-options.hx  |  6 ++++--
 3 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vhost-vdpa.c
+++ b/net/vhost-vdpa.c
@@ -XXX,XX +XXX,XX @@ int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
 
     assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA);
     opts = &netdev->u.vhost_vdpa;
-    if (!opts->vhostdev) {
-        error_setg(errp, "vdpa character device not specified with vhostdev");
+    if (!opts->has_vhostdev && !opts->has_vhostfd) {
+        error_setg(errp,
+                   "vhost-vdpa: neither vhostdev= nor vhostfd= was specified");
         return -1;
     }
 
-    vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
-    if (vdpa_device_fd == -1) {
-        return -errno;
+    if (opts->has_vhostdev && opts->has_vhostfd) {
+        error_setg(errp,
+                   "vhost-vdpa: vhostdev= and vhostfd= are mutually exclusive");
+        return -1;
+    }
+
+    if (opts->has_vhostdev) {
+        vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
+        if (vdpa_device_fd == -1) {
+            return -errno;
+        }
+    } else if (opts->has_vhostfd) {
+        vdpa_device_fd = monitor_fd_param(monitor_cur(), opts->vhostfd, errp);
+        if (vdpa_device_fd == -1) {
+            error_prepend(errp, "vhost-vdpa: unable to parse vhostfd: ");
+            return -1;
+        }
     }
 
     r = vhost_vdpa_get_features(vdpa_device_fd, &features, errp);
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 @@
 # @vhostdev: path of vhost-vdpa device
 #            (default:'/dev/vhost-vdpa-0')
 #
+# @vhostfd: file descriptor of an already opened vhost vdpa device
+#
 # @queues: number of queues to be created for multiqueue vhost-vdpa
 #          (default: 1)
 #
@@ -XXX,XX +XXX,XX @@
 { 'struct': 'NetdevVhostVDPAOptions',
   'data': {
     '*vhostdev':     'str',
+    '*vhostfd':      'str',
     '*queues':       'int',
     '*x-svq':        {'type': 'bool', 'features' : [ 'unstable'] } } }
 
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
     "                configure a vhost-user network, backed by a chardev 'dev'\n"
 #endif
 #ifdef __linux__
-    "-netdev vhost-vdpa,id=str,vhostdev=/path/to/dev\n"
+    "-netdev vhost-vdpa,id=str[,vhostdev=/path/to/dev][,vhostfd=h]\n"
     "                configure a vhost-vdpa network,Establish a vhost-vdpa netdev\n"
+    "                use 'vhostdev=/path/to/dev' to open a vhost vdpa device\n"
+    "                use 'vhostfd=h' to connect to an already opened vhost vdpa device\n"
 #endif
 #ifdef CONFIG_VMNET
     "-netdev vmnet-host,id=str[,isolated=on|off][,net-uuid=uuid]\n"
@@ -XXX,XX +XXX,XX @@ SRST
              -netdev type=vhost-user,id=net0,chardev=chr0 \
              -device virtio-net-pci,netdev=net0
 
-``-netdev vhost-vdpa,vhostdev=/path/to/dev``
+``-netdev vhost-vdpa[,vhostdev=/path/to/dev][,vhostfd=h]``
     Establish a vhost-vdpa netdev.
 
     vDPA device is a device that uses a datapath which complies with
-- 
2.7.4

From: Daniel P. Berrangé <berrange@redhat.com>

The current message when using '-net user...' with SLIRP disabled at
compile time is:

qemu-system-x86_64: -net user: Parameter 'type' expects a net backend type (maybe it is not compiled into this binary)

An observation is that we're using the 'netdev->type' field here which
is an enum value, produced after QAPI has converted from its string
form.

IOW, at this point in the code, we know that the user's specified
type name was a valid network backend. The only possible scenario that
can make the backend init function be NULL, is if support for that
backend was disabled at build time. Given this, we don't need to caveat
our error message with a 'maybe' hint, we can be totally explicit.

The use of QERR_INVALID_PARAMETER_VALUE doesn't really lend itself to
user friendly error message text. Since this is not used to set a
specific QAPI error class, we can simply stop using this pre-formatted
error text and provide something better.

Thus the new message is:

qemu-system-x86_64: -net user: network backend 'user' is not compiled into this binary

The case of passing 'hubport' for -net is also given a message reminding
people they should have used -netdev/-nic instead, as this backend type
is only valid for the modern syntax.

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/net.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
     if (is_netdev) {
         if (netdev->type == NET_CLIENT_DRIVER_NIC ||
             !net_client_init_fun[netdev->type]) {
-            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
-                       "a netdev backend type");
+            error_setg(errp, "network backend '%s' is not compiled into this binary",
+                       NetClientDriver_str(netdev->type));
             return -1;
         }
     } else {
         if (netdev->type == NET_CLIENT_DRIVER_NONE) {
             return 0; /* nothing to do */
         }
-        if (netdev->type == NET_CLIENT_DRIVER_HUBPORT ||
-            !net_client_init_fun[netdev->type]) {
-            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
-                       "a net backend type (maybe it is not compiled "
-                       "into this binary)");
+        if (netdev->type == NET_CLIENT_DRIVER_HUBPORT) {
+            error_setg(errp, "network backend '%s' is only supported with -netdev/-nic",
+                       NetClientDriver_str(netdev->type));
+            return -1;
+        }
+
+        if (!net_client_init_fun[netdev->type]) {
+            error_setg(errp, "network backend '%s' is not compiled into this binary",
+                       NetClientDriver_str(netdev->type));
             return -1;
         }
 
-- 
2.7.4

From: Eugenio Pérez <eperezma@redhat.com>

There was not enough room to accomodate them.

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/virtio/vhost-shadow-virtqueue.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/vhost-shadow-virtqueue.c
+++ b/hw/virtio/vhost-shadow-virtqueue.c
@@ -XXX,XX +XXX,XX @@ void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq,
 size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq)
 {
     size_t desc_size = sizeof(vring_desc_t) * svq->vring.num;
-    size_t avail_size = offsetof(vring_avail_t, ring) +
-                                             sizeof(uint16_t) * svq->vring.num;
+    size_t avail_size = offsetof(vring_avail_t, ring[svq->vring.num]) +
+                                                              sizeof(uint16_t);
 
     return ROUND_UP(desc_size + avail_size, qemu_real_host_page_size());
 }
 
 size_t vhost_svq_device_area_size(const VhostShadowVirtqueue *svq)
 {
-    size_t used_size = offsetof(vring_used_t, ring) +
-                                    sizeof(vring_used_elem_t) * svq->vring.num;
+    size_t used_size = offsetof(vring_used_t, ring[svq->vring.num]) +
+                                                              sizeof(uint16_t);
     return ROUND_UP(used_size, qemu_real_host_page_size());
 }
 
-- 
2.7.4

From: Eugenio Pérez <eperezma@redhat.com>

Actually use the new field of the used ring and tell the device if SVQ
wants to be notified.

The code is not reachable at the moment.

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/virtio/vhost-shadow-virtqueue.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/vhost-shadow-virtqueue.c
+++ b/hw/virtio/vhost-shadow-virtqueue.c
@@ -XXX,XX +XXX,XX @@ static bool vhost_svq_more_used(VhostShadowVirtqueue *svq)
  */
 static bool vhost_svq_enable_notification(VhostShadowVirtqueue *svq)
 {
-    svq->vring.avail->flags &= ~cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT);
-    /* Make sure the flag is written before the read of used_idx */
+    if (virtio_vdev_has_feature(svq->vdev, VIRTIO_RING_F_EVENT_IDX)) {
+        uint16_t *used_event = (uint16_t *)&svq->vring.avail->ring[svq->vring.num];
+        *used_event = svq->shadow_used_idx;
+    } else {
+        svq->vring.avail->flags &= ~cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT);
+    }
+
+    /* Make sure the event is enabled before the read of used_idx */
     smp_mb();
     return !vhost_svq_more_used(svq);
 }
 
 static void vhost_svq_disable_notification(VhostShadowVirtqueue *svq)
 {
-    svq->vring.avail->flags |= cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT);
+    /*
+     * No need to disable notification in the event idx case, since used event
+     * index is already an index too far away.
+     */
+    if (!virtio_vdev_has_feature(svq->vdev, VIRTIO_RING_F_EVENT_IDX)) {
+        svq->vring.avail->flags |= cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT);
+    }
 }
 
 static uint16_t vhost_svq_last_desc_of_chain(const VhostShadowVirtqueue *svq,
-- 
2.7.4

From: Eugenio Pérez <eperezma@redhat.com>

So SVQ code knows if an event is needed.

The code is not reachable at the moment.

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/virtio/vhost-shadow-virtqueue.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

From: Laurent Vivier <lvivier@redhat.com>

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/qemu/sockets.h |  2 ++
 net/net.c              | 62 ++++++++++++++++++++++++++------------------------
 2 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/include/qemu/sockets.h b/include/qemu/sockets.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/sockets.h
+++ b/include/qemu/sockets.h
@@ -XXX,XX +XXX,XX @@ void socket_listen_cleanup(int fd, Error **errp);
 int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp);
 
 /* Old, ipv4 only bits.  Don't use for new code. */
+int convert_host_port(struct sockaddr_in *saddr, const char *host,
+                      const char *port, Error **errp);
 int parse_host_port(struct sockaddr_in *saddr, const char *str,
                     Error **errp);
 int socket_init(void);
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ static QTAILQ_HEAD(, NetClientState) net_clients;
 /***********************************************************/
 /* network device redirectors */
 
-int parse_host_port(struct sockaddr_in *saddr, const char *str,
-                    Error **errp)
+int convert_host_port(struct sockaddr_in *saddr, const char *host,
+                      const char *port, Error **errp)
 {
-    gchar **substrings;
     struct hostent *he;
-    const char *addr, *p, *r;
-    int port, ret = 0;
+    const char *r;
+    long p;
 
     memset(saddr, 0, sizeof(*saddr));
 
-    substrings = g_strsplit(str, ":", 2);
-    if (!substrings || !substrings[0] || !substrings[1]) {
-        error_setg(errp, "host address '%s' doesn't contain ':' "
-                   "separating host from port", str);
-        ret = -1;
-        goto out;
-    }
-
-    addr = substrings[0];
-    p = substrings[1];
-
     saddr->sin_family = AF_INET;
-    if (addr[0] == '\0') {
+    if (host[0] == '\0') {
         saddr->sin_addr.s_addr = 0;
     } else {
-        if (qemu_isdigit(addr[0])) {
-            if (!inet_aton(addr, &saddr->sin_addr)) {
+        if (qemu_isdigit(host[0])) {
+            if (!inet_aton(host, &saddr->sin_addr)) {
                 error_setg(errp, "host address '%s' is not a valid "
-                           "IPv4 address", addr);
-                ret = -1;
-                goto out;
+                           "IPv4 address", host);
+                return -1;
             }
         } else {
-            he = gethostbyname(addr);
+            he = gethostbyname(host);
             if (he == NULL) {
-                error_setg(errp, "can't resolve host address '%s'", addr);
-                ret = -1;
-                goto out;
+                error_setg(errp, "can't resolve host address '%s'", host);
+                return -1;
             }
             saddr->sin_addr = *(struct in_addr *)he->h_addr;
         }
     }
-    port = strtol(p, (char **)&r, 0);
-    if (r == p) {
-        error_setg(errp, "port number '%s' is invalid", p);
+    if (qemu_strtol(port, &r, 0, &p) != 0) {
+        error_setg(errp, "port number '%s' is invalid", port);
+        return -1;
+    }
+    saddr->sin_port = htons(p);
+    return 0;
+}
+
+int parse_host_port(struct sockaddr_in *saddr, const char *str,
+                    Error **errp)
+{
+    gchar **substrings;
+    int ret;
+
+    substrings = g_strsplit(str, ":", 2);
+    if (!substrings || !substrings[0] || !substrings[1]) {
+        error_setg(errp, "host address '%s' doesn't contain ':' "
+                   "separating host from port", str);
         ret = -1;
         goto out;
     }
-    saddr->sin_port = htons(port);
+
+    ret = convert_host_port(saddr, substrings[0], substrings[1], errp);
 
 out:
     g_strfreev(substrings);
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

The only caller passes &error_fatal, so use this directly in the function.

It's what we do for -blockdev, -device, and -object.

Suggested-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/net.h |  2 +-
 net/net.c         | 20 +++++++-------------
 softmmu/vl.c      |  2 +-
 3 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/include/net/net.h b/include/net/net.h
index XXXXXXX..XXXXXXX 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -XXX,XX +XXX,XX @@ extern const char *host_net_devices[];
 /* from net.c */
 int net_client_parse(QemuOptsList *opts_list, const char *str);
 void show_netdevs(void);
-int net_init_clients(Error **errp);
+void net_init_clients(void);
 void net_check_clients(void);
 void net_cleanup(void);
 void hmp_host_net_add(Monitor *mon, const QDict *qdict);
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-int net_init_clients(Error **errp)
+void net_init_clients(void)
 {
     net_change_state_entry =
         qemu_add_vm_change_state_handler(net_vm_change_state_handler, NULL);
 
     QTAILQ_INIT(&net_clients);
 
-    if (qemu_opts_foreach(qemu_find_opts("netdev"),
-                          net_init_netdev, NULL, errp)) {
-        return -1;
-    }
-
-    if (qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL, errp)) {
-        return -1;
-    }
+    qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL,
+                      &error_fatal);
 
-    if (qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL, errp)) {
-        return -1;
-    }
+    qemu_opts_foreach(qemu_find_opts("nic"), net_param_nic, NULL,
+                      &error_fatal);
 
-    return 0;
+    qemu_opts_foreach(qemu_find_opts("net"), net_init_client, NULL,
+                      &error_fatal);
 }
 
 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
diff --git a/softmmu/vl.c b/softmmu/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ static void qemu_create_late_backends(void)
         qtest_server_init(qtest_chrdev, qtest_log, &error_fatal);
     }
 
-    net_init_clients(&error_fatal);
+    net_init_clients();
 
     object_option_foreach_add(object_create_late);
 
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

All net_client_parse() callers exit in case of error.

Move exit(1) to net_client_parse() and remove error checking from
the callers.

Suggested-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/net.h |  2 +-
 net/net.c         |  6 ++----
 softmmu/vl.c      | 12 +++---------
 3 files changed, 6 insertions(+), 14 deletions(-)

From: Laurent Vivier <lvivier@redhat.com>

As qemu_opts_parse_noisily() flattens the QAPI structures ("type" field
of Netdev structure can collides with "type" field of SocketAddress),
we introduce a way to bypass qemu_opts_parse_noisily() and use directly
visit_type_Netdev() to parse the backend parameters.

More details from Markus:

qemu_init() passes the argument of -netdev, -nic, and -net to
net_client_parse().

net_client_parse() parses with qemu_opts_parse_noisily(), passing
QemuOptsList qemu_netdev_opts for -netdev, qemu_nic_opts for -nic, and
qemu_net_opts for -net.  Their desc[] are all empty, which means any
keys are accepted.  The result of the parse (a QemuOpts) is stored in
the QemuOptsList.

Note that QemuOpts is flat by design.  In some places, we layer non-flat
on top using dotted keys convention, but not here.

net_init_clients() iterates over the stored QemuOpts, and passes them to
net_init_netdev(), net_param_nic(), or net_init_client(), respectively.

These functions pass the QemuOpts to net_client_init().  They also do
other things with the QemuOpts, which we can ignore here.

net_client_init() uses the opts visitor to convert the (flat) QemOpts to
a (non-flat) QAPI object Netdev.  Netdev is also the argument of QMP
command netdev_add.

The opts visitor was an early attempt to support QAPI in
(QemuOpts-based) CLI.  It restricts QAPI types to a certain shape; see
commit eb7ee2cbeb "qapi: introduce OptsVisitor".

A more modern way to support QAPI is qobject_input_visitor_new_str().
It uses keyval_parse() instead of QemuOpts for KEY=VALUE,... syntax, and
it also supports JSON syntax.  The former isn't quite as expressive as
JSON, but it's a lot closer than QemuOpts + opts visitor.

This commit paves the way to use of the modern way instead.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/net/net.h |  2 ++
 net/net.c         | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 softmmu/vl.c      |  6 +++++-
 3 files changed, 64 insertions(+), 1 deletion(-)

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 @@ extern NICInfo nd_table[MAX_NICS];
 extern const char *host_net_devices[];
 
 /* from net.c */
+bool netdev_is_modern(const char *optarg);
+void netdev_parse_modern(const char *optarg);
 void net_client_parse(QemuOptsList *opts_list, const char *str);
 void show_netdevs(void);
 void net_init_clients(void);
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@
 #include "net/colo-compare.h"
 #include "net/filter.h"
 #include "qapi/string-output-visitor.h"
+#include "qapi/qobject-input-visitor.h"
 
 /* Net bridge is currently not supported for W32. */
 #if !defined(_WIN32)
@@ -XXX,XX +XXX,XX @@
 static VMChangeStateEntry *net_change_state_entry;
 static QTAILQ_HEAD(, NetClientState) net_clients;
 
+typedef struct NetdevQueueEntry {
+    Netdev *nd;
+    Location loc;
+    QSIMPLEQ_ENTRY(NetdevQueueEntry) entry;
+} NetdevQueueEntry;
+
+typedef QSIMPLEQ_HEAD(, NetdevQueueEntry) NetdevQueue;
+
+static NetdevQueue nd_queue = QSIMPLEQ_HEAD_INITIALIZER(nd_queue);
+
 /***********************************************************/
 /* network device redirectors */
 
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
+static void netdev_init_modern(void)
+{
+    while (!QSIMPLEQ_EMPTY(&nd_queue)) {
+        NetdevQueueEntry *nd = QSIMPLEQ_FIRST(&nd_queue);
+
+        QSIMPLEQ_REMOVE_HEAD(&nd_queue, entry);
+        loc_push_restore(&nd->loc);
+        net_client_init1(nd->nd, true, &error_fatal);
+        loc_pop(&nd->loc);
+        qapi_free_Netdev(nd->nd);
+        g_free(nd);
+    }
+}
+
 void net_init_clients(void)
 {
     net_change_state_entry =
@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
 
     QTAILQ_INIT(&net_clients);
 
+    netdev_init_modern();
+
     qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL,
                       &error_fatal);
 
@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
                       &error_fatal);
 }
 
+/*
+ * Does this -netdev argument use modern rather than traditional syntax?
+ * Modern syntax is to be parsed with netdev_parse_modern().
+ * Traditional syntax is to be parsed with net_client_parse().
+ */
+bool netdev_is_modern(const char *optarg)
+{
+    return false;
+}
+
+/*
+ * netdev_parse_modern() uses modern, more expressive syntax than
+ * net_client_parse(), but supports only the -netdev option.
+ * netdev_parse_modern() appends to @nd_queue, whereas net_client_parse()
+ * appends to @qemu_netdev_opts.
+ */
+void netdev_parse_modern(const char *optarg)
+{
+    Visitor *v;
+    NetdevQueueEntry *nd;
+
+    v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
+    nd = g_new(NetdevQueueEntry, 1);
+    visit_type_Netdev(v, NULL, &nd->nd, &error_fatal);
+    visit_free(v);
+    loc_save(&nd->loc);
+
+    QSIMPLEQ_INSERT_TAIL(&nd_queue, nd, entry);
+}
+
 void net_client_parse(QemuOptsList *opts_list, const char *optarg)
 {
     if (!qemu_opts_parse_noisily(opts_list, optarg, true)) {
diff --git a/softmmu/vl.c b/softmmu/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ void qemu_init(int argc, char **argv)
                 break;
             case QEMU_OPTION_netdev:
                 default_net = 0;
-                net_client_parse(qemu_find_opts("netdev"), optarg);
+                if (netdev_is_modern(optarg)) {
+                    netdev_parse_modern(optarg);
+                } else {
+                    net_client_parse(qemu_find_opts("netdev"), optarg);
+                }
                 break;
             case QEMU_OPTION_nic:
                 default_net = 0;
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Embed the setting of info_str in a function.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/xen_nic.c  |  5 ++---
 include/net/net.h |  1 +
 net/l2tpv3.c      |  3 +--
 net/net.c         | 17 ++++++++++++-----
 net/slirp.c       |  5 ++---
 net/socket.c      | 33 ++++++++++++++-------------------
 net/tap-win32.c   |  3 +--
 net/tap.c         | 13 +++++--------
 net/vde.c         |  3 +--
 net/vhost-user.c  |  3 +--
 net/vhost-vdpa.c  |  2 +-
 11 files changed, 41 insertions(+), 47 deletions(-)

diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/xen_nic.c
+++ b/hw/net/xen_nic.c
@@ -XXX,XX +XXX,XX @@ static int net_init(struct XenLegacyDevice *xendev)
     netdev->nic = qemu_new_nic(&net_xen_info, &netdev->conf,
                                "xen", NULL, netdev);
 
-    snprintf(qemu_get_queue(netdev->nic)->info_str,
-             sizeof(qemu_get_queue(netdev->nic)->info_str),
-             "nic: xenbus vif macaddr=%s", netdev->mac);
+    qemu_set_info_str(qemu_get_queue(netdev->nic),
+                      "nic: xenbus vif macaddr=%s", netdev->mac);
 
     /* fill info */
     xenstore_write_be_int(&netdev->xendev, "feature-rx-copy", 1);
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 @@ ssize_t qemu_send_packet_async(NetClientState *nc, const uint8_t *buf,
 void qemu_purge_queued_packets(NetClientState *nc);
 void qemu_flush_queued_packets(NetClientState *nc);
 void qemu_flush_or_purge_queued_packets(NetClientState *nc, bool purge);
+void qemu_set_info_str(NetClientState *nc, const char *fmt, ...);
 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6]);
 bool qemu_has_ufo(NetClientState *nc);
 bool qemu_has_vnet_hdr(NetClientState *nc);
diff --git a/net/l2tpv3.c b/net/l2tpv3.c
index XXXXXXX..XXXXXXX 100644
--- a/net/l2tpv3.c
+++ b/net/l2tpv3.c
@@ -XXX,XX +XXX,XX @@ int net_init_l2tpv3(const Netdev *netdev,
 
     l2tpv3_read_poll(s, true);
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "l2tpv3: connected");
+    qemu_set_info_str(&s->nc, "l2tpv3: connected");
     return 0;
 outerr:
     qemu_del_net_client(nc);
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@ char *qemu_mac_strdup_printf(const uint8_t *macaddr)
                            macaddr[3], macaddr[4], macaddr[5]);
 }
 
+void qemu_set_info_str(NetClientState *nc, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(nc->info_str, sizeof(nc->info_str), fmt, ap);
+    va_end(ap);
+}
+
 void qemu_format_nic_info_str(NetClientState *nc, uint8_t macaddr[6])
 {
-    snprintf(nc->info_str, sizeof(nc->info_str),
-             "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
-             nc->model,
-             macaddr[0], macaddr[1], macaddr[2],
-             macaddr[3], macaddr[4], macaddr[5]);
+    qemu_set_info_str(nc, "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
+                      nc->model, macaddr[0], macaddr[1], macaddr[2],
+                      macaddr[3], macaddr[4], macaddr[5]);
 }
 
 static int mac_table[256] = {0};
diff --git a/net/slirp.c b/net/slirp.c
index XXXXXXX..XXXXXXX 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -XXX,XX +XXX,XX @@ static int net_slirp_init(NetClientState *peer, const char *model,
 
     nc = qemu_new_net_client(&net_slirp_info, peer, model, name);
 
-    snprintf(nc->info_str, sizeof(nc->info_str),
-             "net=%s,restrict=%s", inet_ntoa(net),
-             restricted ? "on" : "off");
+    qemu_set_info_str(nc, "net=%s,restrict=%s", inet_ntoa(net),
+                      restricted ? "on" : "off");
 
     s = DO_UPCAST(SlirpState, nc, nc);
 
diff --git a/net/socket.c b/net/socket.c
index XXXXXXX..XXXXXXX 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -XXX,XX +XXX,XX @@ static void net_socket_send(void *opaque)
         s->fd = -1;
         net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
         s->nc.link_down = true;
-        memset(s->nc.info_str, 0, sizeof(s->nc.info_str));
+        qemu_set_info_str(&s->nc, "");
 
         return;
     }
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
     /* mcast: save bound address as dst */
     if (is_connected && mcast != NULL) {
         s->dgram_dst = saddr;
-        snprintf(nc->info_str, sizeof(nc->info_str),
-                 "socket: fd=%d (cloned mcast=%s:%d)",
-                 fd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+        qemu_set_info_str(nc, "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 %s", fd, SocketAddressType_str(sa_type));
+        qemu_set_info_str(nc, "socket: fd=%d %s", fd,
+                          SocketAddressType_str(sa_type));
     }
 
     return s;
@@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer,
 
     nc = qemu_new_net_client(&net_socket_info, peer, model, name);
 
-    snprintf(nc->info_str, sizeof(nc->info_str), "socket: fd=%d", fd);
+    qemu_set_info_str(nc, "socket: fd=%d", fd);
 
     s = DO_UPCAST(NetSocketState, nc, nc);
 
@@ -XXX,XX +XXX,XX @@ static void net_socket_accept(void *opaque)
     s->fd = fd;
     s->nc.link_down = false;
     net_socket_connect(s);
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "socket: connection from %s:%d",
-             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+    qemu_set_info_str(&s->nc, "socket: connection from %s:%d",
+                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
 }
 
 static int net_socket_listen_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_socket_connect_init(NetClientState *peer,
         return -1;
     }
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "socket: connect to %s:%d",
-             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+    qemu_set_info_str(&s->nc, "socket: connect to %s:%d",
+                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ static int net_socket_mcast_init(NetClientState *peer,
 
     s->dgram_dst = saddr;
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "socket: mcast=%s:%d",
-             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+    qemu_set_info_str(&s->nc, "socket: mcast=%s:%d",
+                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
     return 0;
 
 }
@@ -XXX,XX +XXX,XX @@ static int net_socket_udp_init(NetClientState *peer,
 
     s->dgram_dst = raddr;
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "socket: udp=%s:%d",
-             inet_ntoa(raddr.sin_addr), ntohs(raddr.sin_port));
+    qemu_set_info_str(&s->nc, "socket: udp=%s:%d", inet_ntoa(raddr.sin_addr),
+                      ntohs(raddr.sin_port));
     return 0;
 }
 
diff --git a/net/tap-win32.c b/net/tap-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/net/tap-win32.c
+++ b/net/tap-win32.c
@@ -XXX,XX +XXX,XX @@ static int tap_win32_init(NetClientState *peer, const char *model,
 
     s = DO_UPCAST(TAPState, nc, nc);
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-             "tap: ifname=%s", ifname);
+    qemu_set_info_str(&s->nc, "tap: ifname=%s", ifname);
 
     s->handle = handle;
 
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,
     }
     s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
 
-    snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", helper,
-             br);
+    qemu_set_info_str(&s->nc, "helper=%s,br=%s", helper, br);
 
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
     }
 
     if (tap->has_fd || tap->has_fds) {
-        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "fd=%d", fd);
+        qemu_set_info_str(&s->nc, "fd=%d", fd);
     } else if (tap->has_helper) {
-        snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s",
-                 tap->helper);
+        qemu_set_info_str(&s->nc, "helper=%s", tap->helper);
     } else {
-        snprintf(s->nc.info_str, sizeof(s->nc.info_str),
-                 "ifname=%s,script=%s,downscript=%s", ifname, script,
-                 downscript);
+        qemu_set_info_str(&s->nc, "ifname=%s,script=%s,downscript=%s", ifname,
+                          script, downscript);
 
         if (strcmp(downscript, "no") != 0) {
             snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);
diff --git a/net/vde.c b/net/vde.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vde.c
+++ b/net/vde.c
@@ -XXX,XX +XXX,XX @@ static int net_vde_init(NetClientState *peer, const char *model,
 
     nc = qemu_new_net_client(&net_vde_info, peer, model, name);
 
-    snprintf(nc->info_str, sizeof(nc->info_str), "sock=%s,fd=%d",
-             sock, vde_datafd(vde));
+    qemu_set_info_str(nc, "sock=%s,fd=%d", sock, vde_datafd(vde));
 
     s = DO_UPCAST(VDEState, nc, nc);
 
diff --git a/net/vhost-user.c b/net/vhost-user.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vhost-user.c
+++ b/net/vhost-user.c
@@ -XXX,XX +XXX,XX @@ static int net_vhost_user_init(NetClientState *peer, const char *device,
     user = g_new0(struct VhostUserState, 1);
     for (i = 0; i < queues; i++) {
         nc = qemu_new_net_client(&net_vhost_user_info, peer, device, name);
-        snprintf(nc->info_str, sizeof(nc->info_str), "vhost-user%d to %s",
-                 i, chr->label);
+        qemu_set_info_str(nc, "vhost-user%d to %s", i, chr->label);
         nc->queue_index = i;
         if (!nc0) {
             nc0 = nc;
diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vhost-vdpa.c
+++ b/net/vhost-vdpa.c
@@ -XXX,XX +XXX,XX @@ static NetClientState *net_vhost_vdpa_init(NetClientState *peer,
         nc = qemu_new_net_control_client(&net_vhost_vdpa_cvq_info, peer,
                                          device, name);
     }
-    snprintf(nc->info_str, sizeof(nc->info_str), TYPE_VHOST_VDPA);
+    qemu_set_info_str(nc, TYPE_VHOST_VDPA);
     s = DO_UPCAST(VhostVDPAState, nc, nc);
 
     s->vhost_vdpa.device_fd = vdpa_device_fd;
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Copied from socket netdev file and modified to use SocketAddress
to be able to introduce new features like unix socket.

"udp" and "mcast" are squashed into dgram netdev, multicast is detected
according to the IP address type.
"listen" and "connect" modes are managed by stream netdev. An optional
parameter "server" defines the mode (off by default)

The two new types need to be parsed the modern way with -netdev, because
with the traditional way, the "type" field of netdev structure collides with
the "type" field of SocketAddress and prevents the correct evaluation of the
command line option. Moreover the traditional way doesn't allow to use
the same type (SocketAddress) several times with the -netdev option
(needed to specify "local" and "remote" addresses).

The previous commit paved the way for parsing the modern way, but
omitted one detail: how to pick modern vs. traditional, in
netdev_is_modern().

We want to pick based on the value of parameter "type".  But how to
extract it from the option argument?

Parsing the option argument, either the modern or the traditional way,
extracts it for us, but only if parsing succeeds.

If parsing fails, there is no good option.  No matter which parser we
pick, it'll be the wrong one for some arguments, and the error
reporting will be confusing.

Fortunately, the traditional parser accepts *anything* when called in
a certain way.  This maximizes our chance to extract the value of
"type", and in turn minimizes the risk of confusing error reporting.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hmp-commands.hx |   2 +-
 net/clients.h   |   6 +
 net/dgram.c     | 537 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 net/hub.c       |   2 +
 net/meson.build |   2 +
 net/net.c       |  30 +++-
 net/stream.c    | 425 ++++++++++++++++++++++++++++++++++++++++++++
 qapi/net.json   |  66 ++++++-
 qemu-options.hx |  12 ++
 9 files changed, 1078 insertions(+), 4 deletions(-)
 create mode 100644 net/dgram.c
 create mode 100644 net/stream.c

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 @@ ERST
     {
         .name       = "netdev_add",
         .args_type  = "netdev:O",
-        .params     = "[user|tap|socket|vde|bridge|hubport|netmap|vhost-user"
+        .params     = "[user|tap|socket|stream|dgram|vde|bridge|hubport|netmap|vhost-user"
 #ifdef CONFIG_VMNET
                       "|vmnet-host|vmnet-shared|vmnet-bridged"
 #endif
diff --git a/net/clients.h b/net/clients.h
index XXXXXXX..XXXXXXX 100644
--- a/net/clients.h
+++ b/net/clients.h
@@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name,
 int net_init_socket(const Netdev *netdev, const char *name,
                     NetClientState *peer, Error **errp);
 
+int net_init_stream(const Netdev *netdev, const char *name,
+                    NetClientState *peer, Error **errp);
+
+int net_init_dgram(const Netdev *netdev, const char *name,
+                   NetClientState *peer, Error **errp);
+
 int net_init_tap(const Netdev *netdev, const char *name,
                  NetClientState *peer, Error **errp);
 
diff --git a/net/dgram.c b/net/dgram.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/dgram.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU System Emulator
+ *
+ * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2022 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+
+#include "net/net.h"
+#include "clients.h"
+#include "monitor/monitor.h"
+#include "qapi/error.h"
+#include "qemu/error-report.h"
+#include "qemu/option.h"
+#include "qemu/sockets.h"
+#include "qemu/iov.h"
+#include "qemu/main-loop.h"
+#include "qemu/cutils.h"
+
+typedef struct NetDgramState {
+    NetClientState nc;
+    int fd;
+    SocketReadState rs;
+    struct sockaddr_in dgram_dst; /* contains destination iff connectionless */
+    bool read_poll;               /* waiting to receive data? */
+    bool write_poll;              /* waiting to transmit data? */
+} NetDgramState;
+
+static void net_dgram_send(void *opaque);
+static void net_dgram_writable(void *opaque);
+
+static void net_dgram_update_fd_handler(NetDgramState *s)
+{
+    qemu_set_fd_handler(s->fd,
+                        s->read_poll ? net_dgram_send : NULL,
+                        s->write_poll ? net_dgram_writable : NULL,
+                        s);
+}
+
+static void net_dgram_read_poll(NetDgramState *s, bool enable)
+{
+    s->read_poll = enable;
+    net_dgram_update_fd_handler(s);
+}
+
+static void net_dgram_write_poll(NetDgramState *s, bool enable)
+{
+    s->write_poll = enable;
+    net_dgram_update_fd_handler(s);
+}
+
+static void net_dgram_writable(void *opaque)
+{
+    NetDgramState *s = opaque;
+
+    net_dgram_write_poll(s, false);
+
+    qemu_flush_queued_packets(&s->nc);
+}
+
+static ssize_t net_dgram_receive(NetClientState *nc,
+                                 const uint8_t *buf, size_t size)
+{
+    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
+    ssize_t ret;
+
+    do {
+        if (s->dgram_dst.sin_family != AF_UNIX) {
+            ret = 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) {
+        net_dgram_write_poll(s, true);
+        return 0;
+    }
+    return ret;
+}
+
+static void net_dgram_send_completed(NetClientState *nc, ssize_t len)
+{
+    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
+
+    if (!s->read_poll) {
+        net_dgram_read_poll(s, true);
+    }
+}
+
+static void net_dgram_rs_finalize(SocketReadState *rs)
+{
+    NetDgramState *s = container_of(rs, NetDgramState, rs);
+
+    if (qemu_send_packet_async(&s->nc, rs->buf,
+                               rs->packet_len,
+                               net_dgram_send_completed) == 0) {
+        net_dgram_read_poll(s, false);
+    }
+}
+
+static void net_dgram_send(void *opaque)
+{
+    NetDgramState *s = opaque;
+    int size;
+
+    size = recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0);
+    if (size < 0) {
+        return;
+    }
+    if (size == 0) {
+        /* end of connection */
+        net_dgram_read_poll(s, false);
+        net_dgram_write_poll(s, false);
+        return;
+    }
+    if (qemu_send_packet_async(&s->nc, s->rs.buf, size,
+                               net_dgram_send_completed) == 0) {
+        net_dgram_read_poll(s, false);
+    }
+}
+
+static int net_dgram_mcast_create(struct sockaddr_in *mcastaddr,
+                                  struct in_addr *localaddr,
+                                  Error **errp)
+{
+    struct ip_mreq imr;
+    int fd;
+    int val, ret;
+#ifdef __OpenBSD__
+    unsigned char loop;
+#else
+    int loop;
+#endif
+
+    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
+        error_setg(errp, "specified mcastaddr %s (0x%08x) "
+                   "does not contain a multicast address",
+                   inet_ntoa(mcastaddr->sin_addr),
+                   (int)ntohl(mcastaddr->sin_addr.s_addr));
+        return -1;
+    }
+
+    fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
+    if (fd < 0) {
+        error_setg_errno(errp, errno, "can't create datagram socket");
+        return -1;
+    }
+
+    /*
+     * Allow multiple sockets to bind the same multicast ip and port by setting
+     * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set
+     * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR
+     * only on posix systems.
+     */
+    val = 1;
+    ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
+    if (ret < 0) {
+        error_setg_errno(errp, errno, "can't set socket option SO_REUSEADDR");
+        goto fail;
+    }
+
+    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
+    if (ret < 0) {
+        error_setg_errno(errp, errno, "can't bind ip=%s to socket",
+                         inet_ntoa(mcastaddr->sin_addr));
+        goto fail;
+    }
+
+    /* Add host to multicast group */
+    imr.imr_multiaddr = mcastaddr->sin_addr;
+    if (localaddr) {
+        imr.imr_interface = *localaddr;
+    } else {
+        imr.imr_interface.s_addr = htonl(INADDR_ANY);
+    }
+
+    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+                     &imr, sizeof(struct ip_mreq));
+    if (ret < 0) {
+        error_setg_errno(errp, errno,
+                         "can't add socket to multicast group %s",
+                         inet_ntoa(imr.imr_multiaddr));
+        goto fail;
+    }
+
+    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
+    loop = 1;
+    ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
+                     &loop, sizeof(loop));
+    if (ret < 0) {
+        error_setg_errno(errp, errno,
+                         "can't force multicast message to loopback");
+        goto fail;
+    }
+
+    /* If a bind address is given, only send packets from that address */
+    if (localaddr != NULL) {
+        ret = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
+                         localaddr, sizeof(*localaddr));
+        if (ret < 0) {
+            error_setg_errno(errp, errno,
+                             "can't set the default network send interface");
+            goto fail;
+        }
+    }
+
+    qemu_socket_set_nonblock(fd);
+    return fd;
+fail:
+    if (fd >= 0) {
+        closesocket(fd);
+    }
+    return -1;
+}
+
+static void net_dgram_cleanup(NetClientState *nc)
+{
+    NetDgramState *s = DO_UPCAST(NetDgramState, nc, nc);
+    if (s->fd != -1) {
+        net_dgram_read_poll(s, false);
+        net_dgram_write_poll(s, false);
+        close(s->fd);
+        s->fd = -1;
+    }
+}
+
+static NetClientInfo net_dgram_socket_info = {
+    .type = NET_CLIENT_DRIVER_DGRAM,
+    .size = sizeof(NetDgramState),
+    .receive = net_dgram_receive,
+    .cleanup = net_dgram_cleanup,
+};
+
+static NetDgramState *net_dgram_fd_init(NetClientState *peer,
+                                        const char *model,
+                                        const char *name,
+                                        int fd, int is_fd,
+                                        SocketAddress *mcast,
+                                        Error **errp)
+{
+    struct sockaddr_in saddr;
+    int newfd;
+    NetClientState *nc;
+    NetDgramState *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() by ONLY ONE process: we must "clone" this
+     * dgram socket --jjo
+     */
+
+    if (is_fd && mcast != NULL) {
+            if (convert_host_port(&saddr, mcast->u.inet.host,
+                                  mcast->u.inet.port, errp) < 0) {
+                goto err;
+            }
+            /* must be bound */
+            if (saddr.sin_addr.s_addr == 0) {
+                error_setg(errp, "can't setup multicast destination address");
+                goto err;
+            }
+            /* clone dgram socket */
+            newfd = net_dgram_mcast_create(&saddr, NULL, errp);
+            if (newfd < 0) {
+                goto err;
+            }
+            /* clone newfd to fd, close newfd */
+            dup2(newfd, fd);
+            close(newfd);
+
+    }
+
+    nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
+
+    s = DO_UPCAST(NetDgramState, nc, nc);
+
+    s->fd = fd;
+    net_socket_rs_init(&s->rs, net_dgram_rs_finalize, false);
+    net_dgram_read_poll(s, true);
+
+    /* mcast: save bound address as dst */
+    if (is_fd && mcast != NULL) {
+        s->dgram_dst = saddr;
+        qemu_set_info_str(nc, "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;
+        }
+
+        qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
+    }
+
+    return s;
+
+err:
+    closesocket(fd);
+    return NULL;
+}
+
+static int net_dgram_mcast_init(NetClientState *peer,
+                                const char *model,
+                                const char *name,
+                                SocketAddress *remote,
+                                SocketAddress *local,
+                                Error **errp)
+{
+    NetDgramState *s;
+    int fd, ret;
+    struct sockaddr_in saddr;
+
+    if (remote->type != SOCKET_ADDRESS_TYPE_INET) {
+        error_setg(errp, "multicast only support inet type");
+        return -1;
+    }
+
+    if (convert_host_port(&saddr, remote->u.inet.host, remote->u.inet.port,
+                          errp) < 0) {
+        return -1;
+    }
+
+    if (!local) {
+        fd = net_dgram_mcast_create(&saddr, NULL, errp);
+        if (fd < 0) {
+            return -1;
+        }
+    } else {
+        switch (local->type) {
+        case SOCKET_ADDRESS_TYPE_INET: {
+            struct in_addr localaddr;
+
+            if (inet_aton(local->u.inet.host, &localaddr) == 0) {
+                error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
+                           local->u.inet.host);
+                return -1;
+            }
+
+            fd = net_dgram_mcast_create(&saddr, &localaddr, errp);
+            if (fd < 0) {
+                return -1;
+            }
+            break;
+        }
+        case SOCKET_ADDRESS_TYPE_FD:
+            fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
+            if (fd == -1) {
+                return -1;
+            }
+            ret = qemu_socket_try_set_nonblock(fd);
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+                                 name, fd);
+                return -1;
+            }
+            break;
+        default:
+            error_setg(errp, "only support inet or fd type for local");
+            return -1;
+        }
+    }
+
+    s = net_dgram_fd_init(peer, model, name, fd,
+                          local->type == SOCKET_ADDRESS_TYPE_FD,
+                          remote, errp);
+    if (!s) {
+        return -1;
+    }
+
+    s->dgram_dst = saddr;
+
+    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr.sin_addr),
+                      ntohs(saddr.sin_port));
+    return 0;
+
+}
+
+
+int net_init_dgram(const Netdev *netdev, const char *name,
+                   NetClientState *peer, Error **errp)
+{
+    NetDgramState *s;
+    int fd, ret;
+    struct sockaddr_in raddr_in;
+    struct sockaddr_in laddr_in;
+    SocketAddress *remote, *local;
+
+    assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
+
+    remote = netdev->u.dgram.remote;
+    local = netdev->u.dgram.local;
+
+    /* detect multicast address */
+    if (remote && remote->type == SOCKET_ADDRESS_TYPE_INET) {
+        struct sockaddr_in mcastaddr;
+
+        if (convert_host_port(&mcastaddr, remote->u.inet.host,
+                              remote->u.inet.port, errp) < 0) {
+            return -1;
+        }
+
+        if (IN_MULTICAST(ntohl(mcastaddr.sin_addr.s_addr))) {
+            return net_dgram_mcast_init(peer, "dram", name, remote, local,
+                                           errp);
+        }
+    }
+
+    /* unicast address */
+    if (!local) {
+        error_setg(errp, "dgram requires local= parameter");
+        return -1;
+    }
+
+    if (remote) {
+        if (local->type == SOCKET_ADDRESS_TYPE_FD) {
+            error_setg(errp, "don't set remote with local.fd");
+            return -1;
+        }
+        if (remote->type != local->type) {
+            error_setg(errp, "remote and local types must be the same");
+            return -1;
+        }
+    } else {
+        if (local->type != SOCKET_ADDRESS_TYPE_FD) {
+            error_setg(errp, "type=inet requires remote parameter");
+            return -1;
+        }
+    }
+
+    switch (local->type) {
+    case SOCKET_ADDRESS_TYPE_INET:
+        if (convert_host_port(&laddr_in, local->u.inet.host, local->u.inet.port,
+                              errp) < 0) {
+            return -1;
+        }
+
+        if (convert_host_port(&raddr_in, remote->u.inet.host,
+                              remote->u.inet.port, errp) < 0) {
+            return -1;
+        }
+
+        fd = qemu_socket(PF_INET, SOCK_DGRAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create datagram socket");
+            return -1;
+        }
+
+        ret = socket_set_fast_reuse(fd);
+        if (ret < 0) {
+            error_setg_errno(errp, errno,
+                             "can't set socket option SO_REUSEADDR");
+            closesocket(fd);
+            return -1;
+        }
+        ret = bind(fd, (struct sockaddr *)&laddr_in, sizeof(laddr_in));
+        if (ret < 0) {
+            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
+                             inet_ntoa(laddr_in.sin_addr));
+            closesocket(fd);
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+        break;
+    case SOCKET_ADDRESS_TYPE_FD:
+        fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
+        if (fd == -1) {
+            return -1;
+        }
+        ret = qemu_socket_try_set_nonblock(fd);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+                             name, fd);
+            return -1;
+        }
+        break;
+    default:
+        error_setg(errp, "only support inet or fd type for local");
+        return -1;
+    }
+
+    s = net_dgram_fd_init(peer, "dgram", name, fd, 0, NULL, errp);
+    if (!s) {
+        return -1;
+    }
+
+    if (remote) {
+        s->dgram_dst = raddr_in;
+    }
+
+    switch (local->type) {
+    case SOCKET_ADDRESS_TYPE_INET:
+        qemu_set_info_str(&s->nc, "udp=%s:%d/%s:%d",
+                          inet_ntoa(laddr_in.sin_addr),
+                          ntohs(laddr_in.sin_port),
+                          inet_ntoa(raddr_in.sin_addr),
+                          ntohs(raddr_in.sin_port));
+        break;
+    case SOCKET_ADDRESS_TYPE_FD:
+        qemu_set_info_str(&s->nc, "fd=%d", fd);
+        break;
+    default:
+        g_assert_not_reached();
+    }
+
+    return 0;
+}
diff --git a/net/hub.c b/net/hub.c
index XXXXXXX..XXXXXXX 100644
--- a/net/hub.c
+++ b/net/hub.c
@@ -XXX,XX +XXX,XX @@ void net_hub_check_clients(void)
             case NET_CLIENT_DRIVER_USER:
             case NET_CLIENT_DRIVER_TAP:
             case NET_CLIENT_DRIVER_SOCKET:
+            case NET_CLIENT_DRIVER_STREAM:
+            case NET_CLIENT_DRIVER_DGRAM:
             case NET_CLIENT_DRIVER_VDE:
             case NET_CLIENT_DRIVER_VHOST_USER:
                 has_host_dev = 1;
diff --git a/net/meson.build b/net/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/net/meson.build
+++ b/net/meson.build
@@ -XXX,XX +XXX,XX @@ softmmu_ss.add(files(
   'net.c',
   'queue.c',
   'socket.c',
+  'stream.c',
+  'dgram.c',
   'util.c',
 ))
 
diff --git a/net/net.c b/net/net.c
index XXXXXXX..XXXXXXX 100644
--- a/net/net.c
+++ b/net/net.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/qemu-print.h"
 #include "qemu/main-loop.h"
 #include "qemu/option.h"
+#include "qemu/keyval.h"
 #include "qapi/error.h"
 #include "qapi/opts-visitor.h"
 #include "sysemu/runstate.h"
@@ -XXX,XX +XXX,XX @@ static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
 #endif
         [NET_CLIENT_DRIVER_TAP]       = net_init_tap,
         [NET_CLIENT_DRIVER_SOCKET]    = net_init_socket,
+        [NET_CLIENT_DRIVER_STREAM]    = net_init_stream,
+        [NET_CLIENT_DRIVER_DGRAM]     = net_init_dgram,
 #ifdef CONFIG_VDE
         [NET_CLIENT_DRIVER_VDE]       = net_init_vde,
 #endif
@@ -XXX,XX +XXX,XX @@ void show_netdevs(void)
     int idx;
     const char *available_netdevs[] = {
         "socket",
+        "stream",
+        "dgram",
         "hubport",
         "tap",
 #ifdef CONFIG_SLIRP
@@ -XXX,XX +XXX,XX @@ void net_init_clients(void)
  */
 bool netdev_is_modern(const char *optarg)
 {
-    return false;
+    QemuOpts *opts;
+    bool is_modern;
+    const char *type;
+    static QemuOptsList dummy_opts = {
+        .name = "netdev",
+        .implied_opt_name = "type",
+        .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
+        .desc = { { } },
+    };
+
+    if (optarg[0] == '{') {
+        /* This is JSON, which means it's modern syntax */
+        return true;
+    }
+
+    opts = qemu_opts_create(&dummy_opts, NULL, false, &error_abort);
+    qemu_opts_do_parse(opts, optarg, dummy_opts.implied_opt_name,
+                       &error_abort);
+    type = qemu_opt_get(opts, "type");
+    is_modern = !g_strcmp0(type, "stream") || !g_strcmp0(type, "dgram");
+
+    qemu_opts_reset(&dummy_opts);
+
+    return is_modern;
 }
 
 /*
diff --git a/net/stream.c b/net/stream.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU System Emulator
+ *
+ * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2022 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+
+#include "net/net.h"
+#include "clients.h"
+#include "monitor/monitor.h"
+#include "qapi/error.h"
+#include "qemu/error-report.h"
+#include "qemu/option.h"
+#include "qemu/sockets.h"
+#include "qemu/iov.h"
+#include "qemu/main-loop.h"
+#include "qemu/cutils.h"
+
+typedef struct NetStreamState {
+    NetClientState nc;
+    int listen_fd;
+    int fd;
+    SocketReadState rs;
+    unsigned int send_index;      /* number of bytes sent*/
+    bool read_poll;               /* waiting to receive data? */
+    bool write_poll;              /* waiting to transmit data? */
+} NetStreamState;
+
+static void net_stream_send(void *opaque);
+static void net_stream_accept(void *opaque);
+static void net_stream_writable(void *opaque);
+
+static void net_stream_update_fd_handler(NetStreamState *s)
+{
+    qemu_set_fd_handler(s->fd,
+                        s->read_poll ? net_stream_send : NULL,
+                        s->write_poll ? net_stream_writable : NULL,
+                        s);
+}
+
+static void net_stream_read_poll(NetStreamState *s, bool enable)
+{
+    s->read_poll = enable;
+    net_stream_update_fd_handler(s);
+}
+
+static void net_stream_write_poll(NetStreamState *s, bool enable)
+{
+    s->write_poll = enable;
+    net_stream_update_fd_handler(s);
+}
+
+static void net_stream_writable(void *opaque)
+{
+    NetStreamState *s = opaque;
+
+    net_stream_write_poll(s, false);
+
+    qemu_flush_queued_packets(&s->nc);
+}
+
+static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
+                                  size_t size)
+{
+    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
+    uint32_t len = htonl(size);
+    struct iovec iov[] = {
+        {
+            .iov_base = &len,
+            .iov_len  = sizeof(len),
+        }, {
+            .iov_base = (void *)buf,
+            .iov_len  = size,
+        },
+    };
+    size_t remaining;
+    ssize_t ret;
+
+    remaining = iov_size(iov, 2) - s->send_index;
+    ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
+
+    if (ret == -1 && errno == EAGAIN) {
+        ret = 0; /* handled further down */
+    }
+    if (ret == -1) {
+        s->send_index = 0;
+        return -errno;
+    }
+    if (ret < (ssize_t)remaining) {
+        s->send_index += ret;
+        net_stream_write_poll(s, true);
+        return 0;
+    }
+    s->send_index = 0;
+    return size;
+}
+
+static void net_stream_send_completed(NetClientState *nc, ssize_t len)
+{
+    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
+
+    if (!s->read_poll) {
+        net_stream_read_poll(s, true);
+    }
+}
+
+static void net_stream_rs_finalize(SocketReadState *rs)
+{
+    NetStreamState *s = container_of(rs, NetStreamState, rs);
+
+    if (qemu_send_packet_async(&s->nc, rs->buf,
+                               rs->packet_len,
+                               net_stream_send_completed) == 0) {
+        net_stream_read_poll(s, false);
+    }
+}
+
+static void net_stream_send(void *opaque)
+{
+    NetStreamState *s = opaque;
+    int size;
+    int ret;
+    uint8_t buf1[NET_BUFSIZE];
+    const uint8_t *buf;
+
+    size = recv(s->fd, buf1, sizeof(buf1), 0);
+    if (size < 0) {
+        if (errno != EWOULDBLOCK) {
+            goto eoc;
+        }
+    } else if (size == 0) {
+        /* end of connection */
+    eoc:
+        net_stream_read_poll(s, false);
+        net_stream_write_poll(s, false);
+        if (s->listen_fd != -1) {
+            qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
+        }
+        closesocket(s->fd);
+
+        s->fd = -1;
+        net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+        s->nc.link_down = true;
+        qemu_set_info_str(&s->nc, "");
+
+        return;
+    }
+    buf = buf1;
+
+    ret = net_fill_rstate(&s->rs, buf, size);
+
+    if (ret == -1) {
+        goto eoc;
+    }
+}
+
+static void net_stream_cleanup(NetClientState *nc)
+{
+    NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
+    if (s->fd != -1) {
+        net_stream_read_poll(s, false);
+        net_stream_write_poll(s, false);
+        close(s->fd);
+        s->fd = -1;
+    }
+    if (s->listen_fd != -1) {
+        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
+        closesocket(s->listen_fd);
+        s->listen_fd = -1;
+    }
+}
+
+static void net_stream_connect(void *opaque)
+{
+    NetStreamState *s = opaque;
+    net_stream_read_poll(s, true);
+}
+
+static NetClientInfo net_stream_info = {
+    .type = NET_CLIENT_DRIVER_STREAM,
+    .size = sizeof(NetStreamState),
+    .receive = net_stream_receive,
+    .cleanup = net_stream_cleanup,
+};
+
+static NetStreamState *net_stream_fd_init(NetClientState *peer,
+                                          const char *model,
+                                          const char *name,
+                                          int fd, int is_connected)
+{
+    NetClientState *nc;
+    NetStreamState *s;
+
+    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+
+    qemu_set_info_str(nc, "fd=%d", fd);
+
+    s = DO_UPCAST(NetStreamState, nc, nc);
+
+    s->fd = fd;
+    s->listen_fd = -1;
+    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+
+    /* Disable Nagle algorithm on TCP sockets to reduce latency */
+    socket_set_nodelay(fd);
+
+    if (is_connected) {
+        net_stream_connect(s);
+    } else {
+        qemu_set_fd_handler(s->fd, NULL, net_stream_connect, s);
+    }
+    return s;
+}
+
+static void net_stream_accept(void *opaque)
+{
+    NetStreamState *s = opaque;
+    struct sockaddr_in saddr;
+    socklen_t len;
+    int fd;
+
+    for (;;) {
+        len = sizeof(saddr);
+        fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
+        if (fd < 0 && errno != EINTR) {
+            return;
+        } else if (fd >= 0) {
+            qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
+            break;
+        }
+    }
+
+    s->fd = fd;
+    s->nc.link_down = false;
+    net_stream_connect(s);
+    qemu_set_info_str(&s->nc, "connection from %s:%d",
+                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+}
+
+static int net_stream_server_init(NetClientState *peer,
+                                  const char *model,
+                                  const char *name,
+                                  SocketAddress *addr,
+                                  Error **errp)
+{
+    NetClientState *nc;
+    NetStreamState *s;
+    int fd, ret;
+
+    switch (addr->type) {
+    case SOCKET_ADDRESS_TYPE_INET: {
+        struct sockaddr_in saddr_in;
+
+        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
+                              errp) < 0) {
+            return -1;
+        }
+
+        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create stream socket");
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+
+        socket_set_fast_reuse(fd);
+
+        ret = bind(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
+        if (ret < 0) {
+            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
+                             inet_ntoa(saddr_in.sin_addr));
+            closesocket(fd);
+            return -1;
+        }
+        break;
+    }
+    case SOCKET_ADDRESS_TYPE_FD:
+        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
+        if (fd == -1) {
+            return -1;
+        }
+        ret = qemu_socket_try_set_nonblock(fd);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+                             name, fd);
+            return -1;
+        }
+        break;
+    default:
+        error_setg(errp, "only support inet or fd type");
+        return -1;
+    }
+
+    ret = listen(fd, 0);
+    if (ret < 0) {
+        error_setg_errno(errp, errno, "can't listen on socket");
+        closesocket(fd);
+        return -1;
+    }
+
+    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+    s = DO_UPCAST(NetStreamState, nc, nc);
+    s->fd = -1;
+    s->listen_fd = fd;
+    s->nc.link_down = true;
+    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+
+    qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
+    return 0;
+}
+
+static int net_stream_client_init(NetClientState *peer,
+                                  const char *model,
+                                  const char *name,
+                                  SocketAddress *addr,
+                                  Error **errp)
+{
+    NetStreamState *s;
+    struct sockaddr_in saddr_in;
+    int fd, connected, ret;
+
+    switch (addr->type) {
+    case SOCKET_ADDRESS_TYPE_INET:
+        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
+                              errp) < 0) {
+            return -1;
+        }
+
+        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create stream socket");
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+
+        connected = 0;
+        for (;;) {
+            ret = connect(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
+            if (ret < 0) {
+                if (errno == EINTR || errno == EWOULDBLOCK) {
+                    /* continue */
+                } else if (errno == EINPROGRESS ||
+                           errno == EALREADY ||
+                           errno == EINVAL) {
+                    break;
+                } else {
+                    error_setg_errno(errp, errno, "can't connect socket");
+                    closesocket(fd);
+                    return -1;
+                }
+            } else {
+                connected = 1;
+                break;
+            }
+        }
+        break;
+    case SOCKET_ADDRESS_TYPE_FD:
+        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
+        if (fd == -1) {
+            return -1;
+        }
+        ret = qemu_socket_try_set_nonblock(fd);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
+                             name, fd);
+            return -1;
+        }
+        connected = 1;
+        break;
+    default:
+        error_setg(errp, "only support inet or fd type");
+        return -1;
+    }
+
+    s = net_stream_fd_init(peer, model, name, fd, connected);
+
+    switch (addr->type) {
+    case SOCKET_ADDRESS_TYPE_INET:
+        qemu_set_info_str(&s->nc, "connect to %s:%d",
+                          inet_ntoa(saddr_in.sin_addr),
+                          ntohs(saddr_in.sin_port));
+        break;
+    case SOCKET_ADDRESS_TYPE_FD:
+        qemu_set_info_str(&s->nc, "connect to fd %d", fd);
+        break;
+    default:
+        g_assert_not_reached();
+    }
+
+    return 0;
+}
+
+int net_init_stream(const Netdev *netdev, const char *name,
+                    NetClientState *peer, Error **errp)
+{
+    const NetdevStreamOptions *sock;
+
+    assert(netdev->type == NET_CLIENT_DRIVER_STREAM);
+    sock = &netdev->u.stream;
+
+    if (!sock->has_server || !sock->server) {
+        return net_stream_client_init(peer, "stream", name, sock->addr, errp);
+    }
+    return net_stream_server_init(peer, "stream", name, sock->addr, errp);
+}
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 @@
 ##
 
 { 'include': 'common.json' }
+{ 'include': 'sockets.json' }
 
 ##
 # @set_link:
@@ -XXX,XX +XXX,XX @@
   'if': 'CONFIG_VMNET' }
 
 ##
+# @NetdevStreamOptions:
+#
+# Configuration info for stream socket netdev
+#
+# @addr: socket address to listen on (server=true)
+#        or connect to (server=false)
+# @server: create server socket (default: false)
+#
+# Only SocketAddress types 'inet' and 'fd' are supported.
+#
+# Since: 7.2
+##
+{ 'struct': 'NetdevStreamOptions',
+  'data': {
+    'addr':   'SocketAddress',
+    '*server': 'bool' } }
+
+##
+# @NetdevDgramOptions:
+#
+# Configuration info for datagram socket netdev.
+#
+# @remote: remote address
+# @local: local address
+#
+# Only SocketAddress types 'inet' and 'fd' are supported.
+#
+# If remote address is present and it's a multicast address, local address
+# is optional. Otherwise local address is required and remote address is
+# optional.
+#
+# .. table:: Valid parameters combination table
+#    :widths: auto
+#
+#    =============  ========  =====
+#    remote         local     okay?
+#    =============  ========  =====
+#    absent         absent    no
+#    absent         not fd    no
+#    absent         fd        yes
+#    multicast      absent    yes
+#    multicast      present   yes
+#    not multicast  absent    no
+#    not multicast  present   yes
+#    =============  ========  =====
+#
+# Since: 7.2
+##
+{ 'struct': 'NetdevDgramOptions',
+  'data': {
+    '*local':  'SocketAddress',
+    '*remote': 'SocketAddress' } }
+
+##
 # @NetClientDriver:
 #
 # Available netdev drivers.
@@ -XXX,XX +XXX,XX @@
 #        @vmnet-host since 7.1
 #        @vmnet-shared since 7.1
 #        @vmnet-bridged since 7.1
+#        @stream since 7.2
+#        @dgram since 7.2
 ##
 { 'enum': 'NetClientDriver',
-  'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'vde',
-            'bridge', 'hubport', 'netmap', 'vhost-user', 'vhost-vdpa',
+  'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'stream',
+            'dgram', 'vde', 'bridge', 'hubport', 'netmap', 'vhost-user',
+            'vhost-vdpa',
             { 'name': 'vmnet-host', 'if': 'CONFIG_VMNET' },
             { 'name': 'vmnet-shared', 'if': 'CONFIG_VMNET' },
             { 'name': 'vmnet-bridged', 'if': 'CONFIG_VMNET' }] }
@@ -XXX,XX +XXX,XX @@
 #        'vmnet-host' - since 7.1
 #        'vmnet-shared' - since 7.1
 #        'vmnet-bridged' - since 7.1
+#        'stream' since 7.2
+#        'dgram' since 7.2
 ##
 { 'union': 'Netdev',
   'base': { 'id': 'str', 'type': 'NetClientDriver' },
@@ -XXX,XX +XXX,XX @@
     'tap':      'NetdevTapOptions',
     'l2tpv3':   'NetdevL2TPv3Options',
     'socket':   'NetdevSocketOptions',
+    'stream':   'NetdevStreamOptions',
+    'dgram':    'NetdevDgramOptions',
     'vde':      'NetdevVdeOptions',
     'bridge':   'NetdevBridgeOptions',
     'hubport':  'NetdevHubPortOptions',
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
     "-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"
     "                configure a network backend to connect to another network\n"
     "                using an UDP tunnel\n"
+    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
+    "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
+    "                configure a network backend to connect to another network\n"
+    "                using a socket connection in stream mode.\n"
+    "-netdev dgram,id=str,remote.type=inet,remote.host=maddr,remote.port=port[,local.type=inet,local.host=addr]\n"
+    "-netdev dgram,id=str,remote.type=inet,remote.host=maddr,remote.port=port[,local.type=fd,local.str=file-descriptor]\n"
+    "                configure a network backend to connect to a multicast maddr and port\n"
+    "                use ``local.host=addr`` to specify the host address to send packets from\n"
+    "-netdev dgram,id=str,local.type=inet,local.host=addr,local.port=port[,remote.type=inet,remote.host=addr,remote.port=port]\n"
+    "-netdev dgram,id=str,local.type=fd,local.str=file-descriptor\n"
+    "                configure a network backend to connect to another network\n"
+    "                using an UDP tunnel\n"
 #ifdef CONFIG_VDE
     "-netdev vde,id=str[,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
     "                configure a network backend to connect to port 'n' of a vde switch\n"
-- 
2.7.4

From: Stefano Brivio <sbrivio@redhat.com>

Other errors are treated as failure by net_socket_connect_init(),
but if connect() returns EINVAL, we'll fail silently. Remove the
related exception.

Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/socket.c | 3 +--
 1 file changed, 1 insertion(+), 2 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 int net_socket_connect_init(NetClientState *peer,
             if (errno == EINTR || errno == EWOULDBLOCK) {
                 /* continue */
             } else if (errno == EINPROGRESS ||
-                       errno == EALREADY ||
-                       errno == EINVAL) {
+                       errno == EALREADY) {
                 break;
             } else {
                 error_setg_errno(errp, errno, "can't connect socket");
-- 
2.7.4

From: Stefano Brivio <sbrivio@redhat.com>

Other errors are treated as failure by net_stream_client_init(),
but if connect() returns EINVAL, we'll fail silently. Remove the
related exception.

Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
[lvivier: applied to net/stream.c]
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/stream.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/net/stream.c b/net/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/net/stream.c
+++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
                 if (errno == EINTR || errno == EWOULDBLOCK) {
                     /* continue */
                 } else if (errno == EINPROGRESS ||
-                           errno == EALREADY ||
-                           errno == EINVAL) {
+                           errno == EALREADY) {
                     break;
                 } else {
                     error_setg_errno(errp, errno, "can't connect socket");
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com> (QAPI schema)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/stream.c    | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++---
 qapi/net.json   |   2 +-
 qemu-options.hx |   1 +
 3 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/net/stream.c b/net/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/net/stream.c
+++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@ static NetStreamState *net_stream_fd_init(NetClientState *peer,
 static void net_stream_accept(void *opaque)
 {
     NetStreamState *s = opaque;
-    struct sockaddr_in saddr;
+    struct sockaddr_storage saddr;
     socklen_t len;
     int fd;
 
@@ -XXX,XX +XXX,XX @@ static void net_stream_accept(void *opaque)
     s->fd = fd;
     s->nc.link_down = false;
     net_stream_connect(s);
-    qemu_set_info_str(&s->nc, "connection from %s:%d",
-                      inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+    switch (saddr.ss_family) {
+    case AF_INET: {
+        struct sockaddr_in *saddr_in = (struct sockaddr_in *)&saddr;
+
+        qemu_set_info_str(&s->nc, "connection from %s:%d",
+                          inet_ntoa(saddr_in->sin_addr),
+                          ntohs(saddr_in->sin_port));
+        break;
+    }
+    case AF_UNIX: {
+        struct sockaddr_un saddr_un;
+
+        len = sizeof(saddr_un);
+        getsockname(s->listen_fd, (struct sockaddr *)&saddr_un, &len);
+        qemu_set_info_str(&s->nc, "connect from %s", saddr_un.sun_path);
+        break;
+    }
+    default:
+        g_assert_not_reached();
+    }
 }
 
 static int net_stream_server_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_stream_server_init(NetClientState *peer,
         }
         break;
     }
+    case SOCKET_ADDRESS_TYPE_UNIX: {
+        struct sockaddr_un saddr_un;
+
+        ret = unlink(addr->u.q_unix.path);
+        if (ret < 0 && errno != ENOENT) {
+            error_setg_errno(errp, errno, "failed to unlink socket %s",
+                             addr->u.q_unix.path);
+            return -1;
+        }
+
+        saddr_un.sun_family = PF_UNIX;
+        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
+                       addr->u.q_unix.path);
+        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
+            error_setg(errp, "UNIX socket path '%s' is too long",
+                       addr->u.q_unix.path);
+            error_append_hint(errp, "Path must be less than %zu bytes\n",
+                              sizeof(saddr_un.sun_path));
+            return -1;
+        }
+
+        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create stream socket");
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+
+        ret = bind(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
+        if (ret < 0) {
+            error_setg_errno(errp, errno, "can't create socket with path: %s",
+                             saddr_un.sun_path);
+            closesocket(fd);
+            return -1;
+        }
+        break;
+    }
     case SOCKET_ADDRESS_TYPE_FD:
         fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
         if (fd == -1) {
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
 {
     NetStreamState *s;
     struct sockaddr_in saddr_in;
+    struct sockaddr_un saddr_un;
     int fd, connected, ret;
 
     switch (addr->type) {
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
             }
         }
         break;
+    case SOCKET_ADDRESS_TYPE_UNIX:
+        saddr_un.sun_family = PF_UNIX;
+        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
+                       addr->u.q_unix.path);
+        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
+            error_setg(errp, "UNIX socket path '%s' is too long",
+                       addr->u.q_unix.path);
+            error_append_hint(errp, "Path must be less than %zu bytes\n",
+                              sizeof(saddr_un.sun_path));
+            return -1;
+        }
+
+        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create stream socket");
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+
+        connected = 0;
+        for (;;) {
+            ret = connect(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
+            if (ret < 0) {
+                if (errno == EINTR || errno == EWOULDBLOCK) {
+                    /* continue */
+                } else if (errno == EAGAIN ||
+                           errno == EALREADY) {
+                    break;
+                } else {
+                    error_setg_errno(errp, errno, "can't connect socket");
+                    closesocket(fd);
+                    return -1;
+                }
+            } else {
+                connected = 1;
+                break;
+            }
+        }
+        break;
     case SOCKET_ADDRESS_TYPE_FD:
         fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
         if (fd == -1) {
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
         connected = 1;
         break;
     default:
-        error_setg(errp, "only support inet or fd type");
+        error_setg(errp, "only support inet, unix or fd type");
         return -1;
     }
 
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
                           inet_ntoa(saddr_in.sin_addr),
                           ntohs(saddr_in.sin_port));
         break;
+    case SOCKET_ADDRESS_TYPE_UNIX:
+        qemu_set_info_str(&s->nc, " connect to %s", saddr_un.sun_path);
+        break;
     case SOCKET_ADDRESS_TYPE_FD:
         qemu_set_info_str(&s->nc, "connect to fd %d", fd);
         break;
     default:
         g_assert_not_reached();
     }
-
     return 0;
 }
 
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 @@
 #        or connect to (server=false)
 # @server: create server socket (default: false)
 #
-# Only SocketAddress types 'inet' and 'fd' are supported.
+# Only SocketAddress types 'unix', 'inet' and 'fd' are supported.
 #
 # Since: 7.2
 ##
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
     "                configure a network backend to connect to another network\n"
     "                using an UDP tunnel\n"
     "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
+    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path\n"
     "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
     "                configure a network backend to connect to another network\n"
     "                using a socket connection in stream mode.\n"
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

dgram_dst is a sockaddr_in structure. To be able to use it with
unix socket, use a pointer to a generic sockaddr structure.

Rename it dest_addr, and store socket length in dest_len.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/dgram.c | 82 +++++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 53 insertions(+), 29 deletions(-)

diff --git a/net/dgram.c b/net/dgram.c
index XXXXXXX..XXXXXXX 100644
--- a/net/dgram.c
+++ b/net/dgram.c
@@ -XXX,XX +XXX,XX @@ typedef struct NetDgramState {
     NetClientState nc;
     int fd;
     SocketReadState rs;
-    struct sockaddr_in dgram_dst; /* contains destination iff connectionless */
     bool read_poll;               /* waiting to receive data? */
     bool write_poll;              /* waiting to transmit data? */
+    /* contains destination iff connectionless */
+    struct sockaddr *dest_addr;
+    socklen_t dest_len;
 } NetDgramState;
 
 static void net_dgram_send(void *opaque);
@@ -XXX,XX +XXX,XX @@ static ssize_t net_dgram_receive(NetClientState *nc,
     ssize_t ret;
 
     do {
-        if (s->dgram_dst.sin_family != AF_UNIX) {
-            ret = sendto(s->fd, buf, size, 0,
-                         (struct sockaddr *)&s->dgram_dst,
-                         sizeof(s->dgram_dst));
+        if (s->dest_addr) {
+            ret = sendto(s->fd, buf, size, 0, s->dest_addr, s->dest_len);
         } else {
             ret = send(s->fd, buf, size, 0);
         }
@@ -XXX,XX +XXX,XX @@ static void net_dgram_cleanup(NetClientState *nc)
         close(s->fd);
         s->fd = -1;
     }
+    g_free(s->dest_addr);
+    s->dest_addr = NULL;
+    s->dest_len = 0;
 }
 
 static NetClientInfo net_dgram_socket_info = {
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
                                         SocketAddress *mcast,
                                         Error **errp)
 {
-    struct sockaddr_in saddr;
+    struct sockaddr_in *saddr = NULL;
     int newfd;
     NetClientState *nc;
     NetDgramState *s;
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
     qapi_free_SocketAddress(sa);
 
     /*
-     * fd passed: multicast: "learn" dgram_dst address from bound address and
+     * fd passed: multicast: "learn" dest_addr address from bound address and
      * save it. Because this may be "shared" socket from a "master" process,
      * datagrams would be recv() by ONLY ONE process: we must "clone" this
      * dgram socket --jjo
      */
 
     if (is_fd && mcast != NULL) {
-            if (convert_host_port(&saddr, mcast->u.inet.host,
-                                  mcast->u.inet.port, errp) < 0) {
+            saddr = g_new(struct sockaddr_in, 1);
+
+            if (convert_host_port(saddr, mcast->u.inet.host, mcast->u.inet.port,
+                                  errp) < 0) {
                 goto err;
             }
             /* must be bound */
-            if (saddr.sin_addr.s_addr == 0) {
+            if (saddr->sin_addr.s_addr == 0) {
                 error_setg(errp, "can't setup multicast destination address");
                 goto err;
             }
             /* clone dgram socket */
-            newfd = net_dgram_mcast_create(&saddr, NULL, errp);
+            newfd = net_dgram_mcast_create(saddr, NULL, errp);
             if (newfd < 0) {
                 goto err;
             }
             /* clone newfd to fd, close newfd */
             dup2(newfd, fd);
             close(newfd);
-
     }
 
     nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
     net_dgram_read_poll(s, true);
 
     /* mcast: save bound address as dst */
-    if (is_fd && mcast != NULL) {
-        s->dgram_dst = saddr;
+    if (saddr) {
+        g_assert(s->dest_addr == NULL);
+        s->dest_addr = (struct sockaddr *)saddr;
+        s->dest_len = sizeof(*saddr);
         qemu_set_info_str(nc, "fd=%d (cloned mcast=%s:%d)", fd,
-                          inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+                          inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port));
     } else {
-        if (sa_type == SOCKET_ADDRESS_TYPE_UNIX) {
-            s->dgram_dst.sin_family = AF_UNIX;
-        }
-
         qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
     }
 
     return s;
 
 err:
+    g_free(saddr);
     closesocket(fd);
     return NULL;
 }
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
 {
     NetDgramState *s;
     int fd, ret;
-    struct sockaddr_in saddr;
+    struct sockaddr_in *saddr;
 
     if (remote->type != SOCKET_ADDRESS_TYPE_INET) {
         error_setg(errp, "multicast only support inet type");
         return -1;
     }
 
-    if (convert_host_port(&saddr, remote->u.inet.host, remote->u.inet.port,
+    saddr = g_new(struct sockaddr_in, 1);
+    if (convert_host_port(saddr, remote->u.inet.host, remote->u.inet.port,
                           errp) < 0) {
+        g_free(saddr);
         return -1;
     }
 
     if (!local) {
-        fd = net_dgram_mcast_create(&saddr, NULL, errp);
+        fd = net_dgram_mcast_create(saddr, NULL, errp);
         if (fd < 0) {
+            g_free(saddr);
             return -1;
         }
     } else {
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
             struct in_addr localaddr;
 
             if (inet_aton(local->u.inet.host, &localaddr) == 0) {
+                g_free(saddr);
                 error_setg(errp, "localaddr '%s' is not a valid IPv4 address",
                            local->u.inet.host);
                 return -1;
             }
 
-            fd = net_dgram_mcast_create(&saddr, &localaddr, errp);
+            fd = net_dgram_mcast_create(saddr, &localaddr, errp);
             if (fd < 0) {
+                g_free(saddr);
                 return -1;
             }
             break;
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
         case SOCKET_ADDRESS_TYPE_FD:
             fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
             if (fd == -1) {
+                g_free(saddr);
                 return -1;
             }
             ret = qemu_socket_try_set_nonblock(fd);
             if (ret < 0) {
+                g_free(saddr);
                 error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
                                  name, fd);
                 return -1;
             }
             break;
         default:
+            g_free(saddr);
             error_setg(errp, "only support inet or fd type for local");
             return -1;
         }
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
                           local->type == SOCKET_ADDRESS_TYPE_FD,
                           remote, errp);
     if (!s) {
+        g_free(saddr);
         return -1;
     }
 
-    s->dgram_dst = saddr;
+    g_assert(s->dest_addr == NULL);
+    s->dest_addr = (struct sockaddr *)saddr;
+    s->dest_len = sizeof(*saddr);
+
+    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr->sin_addr),
+                      ntohs(saddr->sin_port));
 
-    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr.sin_addr),
-                      ntohs(saddr.sin_port));
     return 0;
 
 }
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
 {
     NetDgramState *s;
     int fd, ret;
-    struct sockaddr_in raddr_in;
-    struct sockaddr_in laddr_in;
     SocketAddress *remote, *local;
+    struct sockaddr *dest_addr;
+    struct sockaddr_in laddr_in, raddr_in;
+    socklen_t dest_len;
 
     assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
 
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
             return -1;
         }
         qemu_socket_set_nonblock(fd);
+
+        dest_len = sizeof(raddr_in);
+        dest_addr = g_malloc(dest_len);
+        memcpy(dest_addr, &raddr_in, dest_len);
         break;
     case SOCKET_ADDRESS_TYPE_FD:
         fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
                              name, fd);
             return -1;
         }
+        dest_addr = NULL;
+        dest_len = 0;
         break;
     default:
         error_setg(errp, "only support inet or fd type for local");
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
     }
 
     if (remote) {
-        s->dgram_dst = raddr_in;
+        g_assert(s->dest_addr == NULL);
+        s->dest_addr = dest_addr;
+        s->dest_len = dest_len;
     }
 
     switch (local->type) {
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

It is less complex to manage special cases directly in
net_dgram_mcast_init() and net_dgram_udp_init().

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/dgram.c | 143 ++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 76 insertions(+), 67 deletions(-)

diff --git a/net/dgram.c b/net/dgram.c
index XXXXXXX..XXXXXXX 100644
--- a/net/dgram.c
+++ b/net/dgram.c
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_dgram_socket_info = {
 static NetDgramState *net_dgram_fd_init(NetClientState *peer,
                                         const char *model,
                                         const char *name,
-                                        int fd, int is_fd,
-                                        SocketAddress *mcast,
+                                        int fd,
                                         Error **errp)
 {
-    struct sockaddr_in *saddr = NULL;
-    int newfd;
     NetClientState *nc;
     NetDgramState *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" dest_addr address from bound address and
-     * save it. Because this may be "shared" socket from a "master" process,
-     * datagrams would be recv() by ONLY ONE process: we must "clone" this
-     * dgram socket --jjo
-     */
-
-    if (is_fd && mcast != NULL) {
-            saddr = g_new(struct sockaddr_in, 1);
-
-            if (convert_host_port(saddr, mcast->u.inet.host, mcast->u.inet.port,
-                                  errp) < 0) {
-                goto err;
-            }
-            /* must be bound */
-            if (saddr->sin_addr.s_addr == 0) {
-                error_setg(errp, "can't setup multicast destination address");
-                goto err;
-            }
-            /* clone dgram socket */
-            newfd = net_dgram_mcast_create(saddr, NULL, errp);
-            if (newfd < 0) {
-                goto err;
-            }
-            /* clone newfd to fd, close newfd */
-            dup2(newfd, fd);
-            close(newfd);
-    }
 
     nc = qemu_new_net_client(&net_dgram_socket_info, peer, model, name);
 
@@ -XXX,XX +XXX,XX @@ static NetDgramState *net_dgram_fd_init(NetClientState *peer,
     net_socket_rs_init(&s->rs, net_dgram_rs_finalize, false);
     net_dgram_read_poll(s, true);
 
-    /* mcast: save bound address as dst */
-    if (saddr) {
-        g_assert(s->dest_addr == NULL);
-        s->dest_addr = (struct sockaddr *)saddr;
-        s->dest_len = sizeof(*saddr);
-        qemu_set_info_str(nc, "fd=%d (cloned mcast=%s:%d)", fd,
-                          inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port));
-    } else {
-        qemu_set_info_str(nc, "fd=%d %s", fd, SocketAddressType_str(sa_type));
-    }
-
     return s;
-
-err:
-    g_free(saddr);
-    closesocket(fd);
-    return NULL;
 }
 
 static int net_dgram_mcast_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
             }
             break;
         }
-        case SOCKET_ADDRESS_TYPE_FD:
+        case SOCKET_ADDRESS_TYPE_FD: {
+            int newfd;
+
             fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
             if (fd == -1) {
                 g_free(saddr);
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
                                  name, fd);
                 return -1;
             }
+
+            /*
+             * fd passed: multicast: "learn" dest_addr address from bound
+             * address and save it. Because this may be "shared" socket from a
+             * "master" process, datagrams would be recv() by ONLY ONE process:
+             * we must "clone" this dgram socket --jjo
+             */
+
+            saddr = g_new(struct sockaddr_in, 1);
+
+            if (convert_host_port(saddr, local->u.inet.host, local->u.inet.port,
+                                  errp) < 0) {
+                g_free(saddr);
+                closesocket(fd);
+                return -1;
+            }
+
+            /* must be bound */
+            if (saddr->sin_addr.s_addr == 0) {
+                error_setg(errp, "can't setup multicast destination address");
+                g_free(saddr);
+                closesocket(fd);
+                return -1;
+            }
+            /* clone dgram socket */
+            newfd = net_dgram_mcast_create(saddr, NULL, errp);
+            if (newfd < 0) {
+                g_free(saddr);
+                closesocket(fd);
+                return -1;
+            }
+            /* clone newfd to fd, close newfd */
+            dup2(newfd, fd);
+            close(newfd);
             break;
+        }
         default:
             g_free(saddr);
             error_setg(errp, "only support inet or fd type for local");
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
         }
     }
 
-    s = net_dgram_fd_init(peer, model, name, fd,
-                          local->type == SOCKET_ADDRESS_TYPE_FD,
-                          remote, errp);
+    s = net_dgram_fd_init(peer, model, name, fd, errp);
     if (!s) {
         g_free(saddr);
         return -1;
@@ -XXX,XX +XXX,XX @@ static int net_dgram_mcast_init(NetClientState *peer,
     s->dest_addr = (struct sockaddr *)saddr;
     s->dest_len = sizeof(*saddr);
 
-    qemu_set_info_str(&s->nc, "mcast=%s:%d", inet_ntoa(saddr->sin_addr),
-                      ntohs(saddr->sin_port));
+    if (!local) {
+        qemu_set_info_str(&s->nc, "mcast=%s:%d",
+                          inet_ntoa(saddr->sin_addr),
+                          ntohs(saddr->sin_port));
+    } else {
+        switch (local->type) {
+        case SOCKET_ADDRESS_TYPE_INET:
+            qemu_set_info_str(&s->nc, "mcast=%s:%d",
+                              inet_ntoa(saddr->sin_addr),
+                              ntohs(saddr->sin_port));
+            break;
+        case SOCKET_ADDRESS_TYPE_FD:
+            qemu_set_info_str(&s->nc, "fd=%d (cloned mcast=%s:%d)",
+                              fd, inet_ntoa(saddr->sin_addr),
+                              ntohs(saddr->sin_port));
+            break;
+        default:
+            g_assert_not_reached();
+        }
+    }
 
     return 0;
 
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
         return -1;
     }
 
-    s = net_dgram_fd_init(peer, "dgram", name, fd, 0, NULL, errp);
+    s = net_dgram_fd_init(peer, "dgram", name, fd, errp);
     if (!s) {
         return -1;
     }
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
                           inet_ntoa(raddr_in.sin_addr),
                           ntohs(raddr_in.sin_port));
         break;
-    case SOCKET_ADDRESS_TYPE_FD:
-        qemu_set_info_str(&s->nc, "fd=%d", fd);
+    case SOCKET_ADDRESS_TYPE_FD: {
+        SocketAddress *sa;
+        SocketAddressType sa_type;
+
+        sa = socket_local_address(fd, errp);
+        if (sa) {
+            sa_type = sa->type;
+            qapi_free_SocketAddress(sa);
+
+            qemu_set_info_str(&s->nc, "fd=%d %s", fd,
+                              SocketAddressType_str(sa_type));
+        } else {
+            qemu_set_info_str(&s->nc, "fd=%d", fd);
+        }
         break;
+    }
     default:
         g_assert_not_reached();
     }
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Stefano Brivio <sbrivio@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com> (QAPI schema)
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/dgram.c     | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 qapi/net.json   |  2 +-
 qemu-options.hx |  1 +
 3 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/net/dgram.c b/net/dgram.c
index XXXXXXX..XXXXXXX 100644
--- a/net/dgram.c
+++ b/net/dgram.c
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
     SocketAddress *remote, *local;
     struct sockaddr *dest_addr;
     struct sockaddr_in laddr_in, raddr_in;
+    struct sockaddr_un laddr_un, raddr_un;
     socklen_t dest_len;
 
     assert(netdev->type == NET_CLIENT_DRIVER_DGRAM);
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
         }
     } else {
         if (local->type != SOCKET_ADDRESS_TYPE_FD) {
-            error_setg(errp, "type=inet requires remote parameter");
+            error_setg(errp,
+                       "type=inet or type=unix requires remote parameter");
             return -1;
         }
     }
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
         dest_addr = g_malloc(dest_len);
         memcpy(dest_addr, &raddr_in, dest_len);
         break;
+    case SOCKET_ADDRESS_TYPE_UNIX:
+        ret = unlink(local->u.q_unix.path);
+        if (ret < 0 && errno != ENOENT) {
+            error_setg_errno(errp, errno, "failed to unlink socket %s",
+                             local->u.q_unix.path);
+            return -1;
+        }
+
+        laddr_un.sun_family = PF_UNIX;
+        ret = snprintf(laddr_un.sun_path, sizeof(laddr_un.sun_path), "%s",
+                       local->u.q_unix.path);
+        if (ret < 0 || ret >= sizeof(laddr_un.sun_path)) {
+            error_setg(errp, "UNIX socket path '%s' is too long",
+                       local->u.q_unix.path);
+            error_append_hint(errp, "Path must be less than %zu bytes\n",
+                              sizeof(laddr_un.sun_path));
+        }
+
+        raddr_un.sun_family = PF_UNIX;
+        ret = snprintf(raddr_un.sun_path, sizeof(raddr_un.sun_path), "%s",
+                       remote->u.q_unix.path);
+        if (ret < 0 || ret >= sizeof(raddr_un.sun_path)) {
+            error_setg(errp, "UNIX socket path '%s' is too long",
+                       remote->u.q_unix.path);
+            error_append_hint(errp, "Path must be less than %zu bytes\n",
+                              sizeof(raddr_un.sun_path));
+        }
+
+        fd = qemu_socket(PF_UNIX, SOCK_DGRAM, 0);
+        if (fd < 0) {
+            error_setg_errno(errp, errno, "can't create datagram socket");
+            return -1;
+        }
+
+        ret = bind(fd, (struct sockaddr *)&laddr_un, sizeof(laddr_un));
+        if (ret < 0) {
+            error_setg_errno(errp, errno, "can't bind unix=%s to socket",
+                             laddr_un.sun_path);
+            closesocket(fd);
+            return -1;
+        }
+        qemu_socket_set_nonblock(fd);
+
+        dest_len = sizeof(raddr_un);
+        dest_addr = g_malloc(dest_len);
+        memcpy(dest_addr, &raddr_un, dest_len);
+        break;
     case SOCKET_ADDRESS_TYPE_FD:
         fd = monitor_fd_param(monitor_cur(), local->u.fd.str, errp);
         if (fd == -1) {
@@ -XXX,XX +XXX,XX @@ int net_init_dgram(const Netdev *netdev, const char *name,
                           inet_ntoa(raddr_in.sin_addr),
                           ntohs(raddr_in.sin_port));
         break;
+    case SOCKET_ADDRESS_TYPE_UNIX:
+        qemu_set_info_str(&s->nc, "udp=%s:%s",
+                          laddr_un.sun_path, raddr_un.sun_path);
+        break;
     case SOCKET_ADDRESS_TYPE_FD: {
         SocketAddress *sa;
         SocketAddressType sa_type;
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 @@
 # @remote: remote address
 # @local: local address
 #
-# Only SocketAddress types 'inet' and 'fd' are supported.
+# Only SocketAddress types 'unix', 'inet' and 'fd' are supported.
 #
 # If remote address is present and it's a multicast address, local address
 # is optional. Otherwise local address is required and remote address is
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
     "                configure a network backend to connect to a multicast maddr and port\n"
     "                use ``local.host=addr`` to specify the host address to send packets from\n"
     "-netdev dgram,id=str,local.type=inet,local.host=addr,local.port=port[,remote.type=inet,remote.host=addr,remote.port=port]\n"
+    "-netdev dgram,id=str,local.type=unix,local.path=path[,remote.type=unix,remote.path=path]\n"
     "-netdev dgram,id=str,local.type=fd,local.str=file-descriptor\n"
     "                configure a network backend to connect to another network\n"
     "                using an UDP tunnel\n"
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Rename SocketAddress_to_str() to socket_uri() and move it to
util/qemu-sockets.c close to socket_parse().

socket_uri() generates a string from a SocketAddress while
socket_parse() generates a SocketAddress from a string.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 include/qemu/sockets.h |  2 +-
 monitor/hmp-cmds.c     | 23 +----------------------
 util/qemu-sockets.c    | 20 ++++++++++++++++++++
 3 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/include/qemu/sockets.h b/include/qemu/sockets.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/sockets.h
+++ b/include/qemu/sockets.h
@@ -XXX,XX +XXX,XX @@ NetworkAddressFamily inet_netfamily(int family);
 int unix_listen(const char *path, Error **errp);
 int unix_connect(const char *path, Error **errp);
 
+char *socket_uri(SocketAddress *addr);
 SocketAddress *socket_parse(const char *str, Error **errp);
 int socket_connect(SocketAddress *addr, Error **errp);
 int socket_listen(SocketAddress *addr, int num, Error **errp);
@@ -XXX,XX +XXX,XX @@ SocketAddress *socket_address_flatten(SocketAddressLegacy *addr);
  * Return 0 on success.
  */
 int socket_address_parse_named_fd(SocketAddress *addr, Error **errp);
-
 #endif /* QEMU_SOCKETS_H */
diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/monitor/hmp-cmds.c
+++ b/monitor/hmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
     qapi_free_MouseInfoList(mice_list);
 }
 
-static char *SocketAddress_to_str(SocketAddress *addr)
-{
-    switch (addr->type) {
-    case SOCKET_ADDRESS_TYPE_INET:
-        return g_strdup_printf("tcp:%s:%s",
-                               addr->u.inet.host,
-                               addr->u.inet.port);
-    case SOCKET_ADDRESS_TYPE_UNIX:
-        return g_strdup_printf("unix:%s",
-                               addr->u.q_unix.path);
-    case SOCKET_ADDRESS_TYPE_FD:
-        return g_strdup_printf("fd:%s", addr->u.fd.str);
-    case SOCKET_ADDRESS_TYPE_VSOCK:
-        return g_strdup_printf("tcp:%s:%s",
-                               addr->u.vsock.cid,
-                               addr->u.vsock.port);
-    default:
-        return g_strdup("unknown address type");
-    }
-}
-
 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
 {
     MigrationInfo *info;
@@ -XXX,XX +XXX,XX @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
         monitor_printf(mon, "socket address: [\n");
 
         for (addr = info->socket_address; addr; addr = addr->next) {
-            char *s = SocketAddress_to_str(addr->value);
+            char *s = socket_uri(addr->value);
             monitor_printf(mon, "\t%s\n", s);
             g_free(s);
         }
diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-sockets.c
+++ b/util/qemu-sockets.c
@@ -XXX,XX +XXX,XX @@ int unix_connect(const char *path, Error **errp)
     return sock;
 }
 
+char *socket_uri(SocketAddress *addr)
+{
+    switch (addr->type) {
+    case SOCKET_ADDRESS_TYPE_INET:
+        return g_strdup_printf("tcp:%s:%s",
+                               addr->u.inet.host,
+                               addr->u.inet.port);
+    case SOCKET_ADDRESS_TYPE_UNIX:
+        return g_strdup_printf("unix:%s",
+                               addr->u.q_unix.path);
+    case SOCKET_ADDRESS_TYPE_FD:
+        return g_strdup_printf("fd:%s", addr->u.fd.str);
+    case SOCKET_ADDRESS_TYPE_VSOCK:
+        return g_strdup_printf("tcp:%s:%s",
+                               addr->u.vsock.cid,
+                               addr->u.vsock.port);
+    default:
+        return g_strdup("unknown address type");
+    }
+}
 
 SocketAddress *socket_parse(const char *str, Error **errp)
 {
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

To be consistent with socket_uri(), add 'tcp:' prefix for inet type in
socket_parse(), by default socket_parse() use tcp when no prefix is
provided (format is host:port).

In socket_uri(), use 'vsock:' prefix for vsock type rather than 'tcp:'
because it makes a vsock address look like an inet address with CID
misinterpreted as host.
Goes back to commit 9aca82ba31 "migration: Create socket-address parameter"

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 util/qemu-sockets.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-sockets.c
+++ b/util/qemu-sockets.c
@@ -XXX,XX +XXX,XX @@ char *socket_uri(SocketAddress *addr)
     case SOCKET_ADDRESS_TYPE_FD:
         return g_strdup_printf("fd:%s", addr->u.fd.str);
     case SOCKET_ADDRESS_TYPE_VSOCK:
-        return g_strdup_printf("tcp:%s:%s",
+        return g_strdup_printf("vsock:%s:%s",
                                addr->u.vsock.cid,
                                addr->u.vsock.port);
     default:
@@ -XXX,XX +XXX,XX @@ SocketAddress *socket_parse(const char *str, Error **errp)
         if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) {
             goto fail;
         }
+    } else if (strstart(str, "tcp:", NULL)) {
+        addr->type = SOCKET_ADDRESS_TYPE_INET;
+        if (inet_parse(&addr->u.inet, str + strlen("tcp:"), errp)) {
+            goto fail;
+        }
     } else {
         addr->type = SOCKET_ADDRESS_TYPE_INET;
         if (inet_parse(&addr->u.inet, str, errp)) {
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

Use QIOChannel, QIOChannelSocket and QIONetListener.
This allows net/stream to use all the available parameters provided by
SocketAddress.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/stream.c    | 492 ++++++++++++++++++++------------------------------------
 qemu-options.hx |   4 +-
 2 files changed, 178 insertions(+), 318 deletions(-)

diff --git a/net/stream.c b/net/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/net/stream.c
+++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/iov.h"
 #include "qemu/main-loop.h"
 #include "qemu/cutils.h"
+#include "io/channel.h"
+#include "io/channel-socket.h"
+#include "io/net-listener.h"
 
 typedef struct NetStreamState {
     NetClientState nc;
-    int listen_fd;
-    int fd;
+    QIOChannel *listen_ioc;
+    QIONetListener *listener;
+    QIOChannel *ioc;
+    guint ioc_read_tag;
+    guint ioc_write_tag;
     SocketReadState rs;
     unsigned int send_index;      /* number of bytes sent*/
-    bool read_poll;               /* waiting to receive data? */
-    bool write_poll;              /* waiting to transmit data? */
 } NetStreamState;
 
-static void net_stream_send(void *opaque);
-static void net_stream_accept(void *opaque);
-static void net_stream_writable(void *opaque);
+static void net_stream_listen(QIONetListener *listener,
+                              QIOChannelSocket *cioc,
+                              void *opaque);
 
-static void net_stream_update_fd_handler(NetStreamState *s)
+static gboolean net_stream_writable(QIOChannel *ioc,
+                                    GIOCondition condition,
+                                    gpointer data)
 {
-    qemu_set_fd_handler(s->fd,
-                        s->read_poll ? net_stream_send : NULL,
-                        s->write_poll ? net_stream_writable : NULL,
-                        s);
-}
-
-static void net_stream_read_poll(NetStreamState *s, bool enable)
-{
-    s->read_poll = enable;
-    net_stream_update_fd_handler(s);
-}
-
-static void net_stream_write_poll(NetStreamState *s, bool enable)
-{
-    s->write_poll = enable;
-    net_stream_update_fd_handler(s);
-}
-
-static void net_stream_writable(void *opaque)
-{
-    NetStreamState *s = opaque;
+    NetStreamState *s = data;
 
-    net_stream_write_poll(s, false);
+    s->ioc_write_tag = 0;
 
     qemu_flush_queued_packets(&s->nc);
+
+    return G_SOURCE_REMOVE;
 }
 
 static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
@@ -XXX,XX +XXX,XX @@ static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
             .iov_len  = size,
         },
     };
+    struct iovec local_iov[2];
+    unsigned int nlocal_iov;
     size_t remaining;
     ssize_t ret;
 
     remaining = iov_size(iov, 2) - s->send_index;
-    ret = iov_send(s->fd, iov, 2, s->send_index, remaining);
-
-    if (ret == -1 && errno == EAGAIN) {
+    nlocal_iov = iov_copy(local_iov, 2, iov, 2, s->send_index, remaining);
+    ret = qio_channel_writev(s->ioc, local_iov, nlocal_iov, NULL);
+    if (ret == QIO_CHANNEL_ERR_BLOCK) {
         ret = 0; /* handled further down */
     }
     if (ret == -1) {
@@ -XXX,XX +XXX,XX @@ static ssize_t net_stream_receive(NetClientState *nc, const uint8_t *buf,
     }
     if (ret < (ssize_t)remaining) {
         s->send_index += ret;
-        net_stream_write_poll(s, true);
+        s->ioc_write_tag = qio_channel_add_watch(s->ioc, G_IO_OUT,
+                                                 net_stream_writable, s, NULL);
         return 0;
     }
     s->send_index = 0;
     return size;
 }
 
+static gboolean net_stream_send(QIOChannel *ioc,
+                                GIOCondition condition,
+                                gpointer data);
+
 static void net_stream_send_completed(NetClientState *nc, ssize_t len)
 {
     NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
 
-    if (!s->read_poll) {
-        net_stream_read_poll(s, true);
+    if (!s->ioc_read_tag) {
+        s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN,
+                                                net_stream_send, s, NULL);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void net_stream_rs_finalize(SocketReadState *rs)
     if (qemu_send_packet_async(&s->nc, rs->buf,
                                rs->packet_len,
                                net_stream_send_completed) == 0) {
-        net_stream_read_poll(s, false);
+        if (s->ioc_read_tag) {
+            g_source_remove(s->ioc_read_tag);
+            s->ioc_read_tag = 0;
+        }
     }
 }
 
-static void net_stream_send(void *opaque)
+static gboolean net_stream_send(QIOChannel *ioc,
+                                GIOCondition condition,
+                                gpointer data)
 {
-    NetStreamState *s = opaque;
+    NetStreamState *s = data;
     int size;
     int ret;
-    uint8_t buf1[NET_BUFSIZE];
-    const uint8_t *buf;
+    char buf1[NET_BUFSIZE];
+    const char *buf;
 
-    size = recv(s->fd, buf1, sizeof(buf1), 0);
+    size = qio_channel_read(s->ioc, buf1, sizeof(buf1), NULL);
     if (size < 0) {
         if (errno != EWOULDBLOCK) {
             goto eoc;
@@ -XXX,XX +XXX,XX @@ static void net_stream_send(void *opaque)
     } else if (size == 0) {
         /* end of connection */
     eoc:
-        net_stream_read_poll(s, false);
-        net_stream_write_poll(s, false);
-        if (s->listen_fd != -1) {
-            qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
+        s->ioc_read_tag = 0;
+        if (s->ioc_write_tag) {
+            g_source_remove(s->ioc_write_tag);
+            s->ioc_write_tag = 0;
         }
-        closesocket(s->fd);
+        if (s->listener) {
+            qio_net_listener_set_client_func(s->listener, net_stream_listen,
+                                             s, NULL);
+        }
+        object_unref(OBJECT(s->ioc));
+        s->ioc = NULL;
 
-        s->fd = -1;
         net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
         s->nc.link_down = true;
         qemu_set_info_str(&s->nc, "");
 
-        return;
+        return G_SOURCE_REMOVE;
     }
     buf = buf1;
 
-    ret = net_fill_rstate(&s->rs, buf, size);
+    ret = net_fill_rstate(&s->rs, (const uint8_t *)buf, size);
 
     if (ret == -1) {
         goto eoc;
     }
+
+    return G_SOURCE_CONTINUE;
 }
 
 static void net_stream_cleanup(NetClientState *nc)
 {
     NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);
-    if (s->fd != -1) {
-        net_stream_read_poll(s, false);
-        net_stream_write_poll(s, false);
-        close(s->fd);
-        s->fd = -1;
+    if (s->ioc) {
+        if (QIO_CHANNEL_SOCKET(s->ioc)->fd != -1) {
+            if (s->ioc_read_tag) {
+                g_source_remove(s->ioc_read_tag);
+                s->ioc_read_tag = 0;
+            }
+            if (s->ioc_write_tag) {
+                g_source_remove(s->ioc_write_tag);
+                s->ioc_write_tag = 0;
+            }
+        }
+        object_unref(OBJECT(s->ioc));
+        s->ioc = NULL;
     }
-    if (s->listen_fd != -1) {
-        qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
-        closesocket(s->listen_fd);
-        s->listen_fd = -1;
+    if (s->listen_ioc) {
+        if (s->listener) {
+            qio_net_listener_disconnect(s->listener);
+            object_unref(OBJECT(s->listener));
+            s->listener = NULL;
+        }
+        object_unref(OBJECT(s->listen_ioc));
+        s->listen_ioc = NULL;
     }
 }
 
-static void net_stream_connect(void *opaque)
-{
-    NetStreamState *s = opaque;
-    net_stream_read_poll(s, true);
-}
-
 static NetClientInfo net_stream_info = {
     .type = NET_CLIENT_DRIVER_STREAM,
     .size = sizeof(NetStreamState),
@@ -XXX,XX +XXX,XX @@ static NetClientInfo net_stream_info = {
     .cleanup = net_stream_cleanup,
 };
 
-static NetStreamState *net_stream_fd_init(NetClientState *peer,
-                                          const char *model,
-                                          const char *name,
-                                          int fd, int is_connected)
+static void net_stream_listen(QIONetListener *listener,
+                              QIOChannelSocket *cioc,
+                              void *opaque)
 {
-    NetClientState *nc;
-    NetStreamState *s;
-
-    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+    NetStreamState *s = opaque;
+    SocketAddress *addr;
+    char *uri;
 
-    qemu_set_info_str(nc, "fd=%d", fd);
+    object_ref(OBJECT(cioc));
 
-    s = DO_UPCAST(NetStreamState, nc, nc);
+    qio_net_listener_set_client_func(s->listener, NULL, s, NULL);
 
-    s->fd = fd;
-    s->listen_fd = -1;
-    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+    s->ioc = QIO_CHANNEL(cioc);
+    qio_channel_set_name(s->ioc, "stream-server");
+    s->nc.link_down = false;
 
-    /* Disable Nagle algorithm on TCP sockets to reduce latency */
-    socket_set_nodelay(fd);
+    s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
+                                            s, NULL);
 
-    if (is_connected) {
-        net_stream_connect(s);
+    if (cioc->localAddr.ss_family == AF_UNIX) {
+        addr = qio_channel_socket_get_local_address(cioc, NULL);
     } else {
-        qemu_set_fd_handler(s->fd, NULL, net_stream_connect, s);
+        addr = qio_channel_socket_get_remote_address(cioc, NULL);
     }
-    return s;
+    g_assert(addr != NULL);
+    uri = socket_uri(addr);
+    qemu_set_info_str(&s->nc, uri);
+    g_free(uri);
+    qapi_free_SocketAddress(addr);
 }
 
-static void net_stream_accept(void *opaque)
+static void net_stream_server_listening(QIOTask *task, gpointer opaque)
 {
     NetStreamState *s = opaque;
-    struct sockaddr_storage saddr;
-    socklen_t len;
-    int fd;
-
-    for (;;) {
-        len = sizeof(saddr);
-        fd = qemu_accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
-        if (fd < 0 && errno != EINTR) {
-            return;
-        } else if (fd >= 0) {
-            qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
-            break;
-        }
-    }
+    QIOChannelSocket *listen_sioc = QIO_CHANNEL_SOCKET(s->listen_ioc);
+    SocketAddress *addr;
+    int ret;
 
-    s->fd = fd;
-    s->nc.link_down = false;
-    net_stream_connect(s);
-    switch (saddr.ss_family) {
-    case AF_INET: {
-        struct sockaddr_in *saddr_in = (struct sockaddr_in *)&saddr;
-
-        qemu_set_info_str(&s->nc, "connection from %s:%d",
-                          inet_ntoa(saddr_in->sin_addr),
-                          ntohs(saddr_in->sin_port));
-        break;
+    if (listen_sioc->fd < 0) {
+        qemu_set_info_str(&s->nc, "connection error");
+        return;
     }
-    case AF_UNIX: {
-        struct sockaddr_un saddr_un;
 
-        len = sizeof(saddr_un);
-        getsockname(s->listen_fd, (struct sockaddr *)&saddr_un, &len);
-        qemu_set_info_str(&s->nc, "connect from %s", saddr_un.sun_path);
-        break;
-    }
-    default:
-        g_assert_not_reached();
+    addr = qio_channel_socket_get_local_address(listen_sioc, NULL);
+    g_assert(addr != NULL);
+    ret = qemu_socket_try_set_nonblock(listen_sioc->fd);
+    if (addr->type == SOCKET_ADDRESS_TYPE_FD && ret < 0) {
+        qemu_set_info_str(&s->nc, "can't use file descriptor %s (errno %d)",
+                          addr->u.fd.str, -ret);
+        return;
     }
+    g_assert(ret == 0);
+    qapi_free_SocketAddress(addr);
+
+    s->nc.link_down = true;
+    s->listener = qio_net_listener_new();
+
+    net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
+    qio_net_listener_set_client_func(s->listener, net_stream_listen, s, NULL);
+    qio_net_listener_add(s->listener, listen_sioc);
 }
 
 static int net_stream_server_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_stream_server_init(NetClientState *peer,
 {
     NetClientState *nc;
     NetStreamState *s;
-    int fd, ret;
+    QIOChannelSocket *listen_sioc = qio_channel_socket_new();
 
-    switch (addr->type) {
-    case SOCKET_ADDRESS_TYPE_INET: {
-        struct sockaddr_in saddr_in;
-
-        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
-                              errp) < 0) {
-            return -1;
-        }
-
-        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
-        if (fd < 0) {
-            error_setg_errno(errp, errno, "can't create stream socket");
-            return -1;
-        }
-        qemu_socket_set_nonblock(fd);
+    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+    s = DO_UPCAST(NetStreamState, nc, nc);
 
-        socket_set_fast_reuse(fd);
+    s->listen_ioc = QIO_CHANNEL(listen_sioc);
+    qio_channel_socket_listen_async(listen_sioc, addr, 0,
+                                    net_stream_server_listening, s,
+                                    NULL, NULL);
 
-        ret = bind(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
-        if (ret < 0) {
-            error_setg_errno(errp, errno, "can't bind ip=%s to socket",
-                             inet_ntoa(saddr_in.sin_addr));
-            closesocket(fd);
-            return -1;
-        }
-        break;
-    }
-    case SOCKET_ADDRESS_TYPE_UNIX: {
-        struct sockaddr_un saddr_un;
-
-        ret = unlink(addr->u.q_unix.path);
-        if (ret < 0 && errno != ENOENT) {
-            error_setg_errno(errp, errno, "failed to unlink socket %s",
-                             addr->u.q_unix.path);
-            return -1;
-        }
+    return 0;
+}
 
-        saddr_un.sun_family = PF_UNIX;
-        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
-                       addr->u.q_unix.path);
-        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
-            error_setg(errp, "UNIX socket path '%s' is too long",
-                       addr->u.q_unix.path);
-            error_append_hint(errp, "Path must be less than %zu bytes\n",
-                              sizeof(saddr_un.sun_path));
-            return -1;
-        }
+static void net_stream_client_connected(QIOTask *task, gpointer opaque)
+{
+    NetStreamState *s = opaque;
+    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(s->ioc);
+    SocketAddress *addr;
+    gchar *uri;
+    int ret;
 
-        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
-        if (fd < 0) {
-            error_setg_errno(errp, errno, "can't create stream socket");
-            return -1;
-        }
-        qemu_socket_set_nonblock(fd);
-
-        ret = bind(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
-        if (ret < 0) {
-            error_setg_errno(errp, errno, "can't create socket with path: %s",
-                             saddr_un.sun_path);
-            closesocket(fd);
-            return -1;
-        }
-        break;
-    }
-    case SOCKET_ADDRESS_TYPE_FD:
-        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
-        if (fd == -1) {
-            return -1;
-        }
-        ret = qemu_socket_try_set_nonblock(fd);
-        if (ret < 0) {
-            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
-                             name, fd);
-            return -1;
-        }
-        break;
-    default:
-        error_setg(errp, "only support inet or fd type");
-        return -1;
+    if (sioc->fd < 0) {
+        qemu_set_info_str(&s->nc, "connection error");
+        goto error;
     }
 
-    ret = listen(fd, 0);
-    if (ret < 0) {
-        error_setg_errno(errp, errno, "can't listen on socket");
-        closesocket(fd);
-        return -1;
+    addr = qio_channel_socket_get_remote_address(sioc, NULL);
+    g_assert(addr != NULL);
+    uri = socket_uri(addr);
+    qemu_set_info_str(&s->nc, uri);
+    g_free(uri);
+
+    ret = qemu_socket_try_set_nonblock(sioc->fd);
+    if (addr->type == SOCKET_ADDRESS_TYPE_FD && ret < 0) {
+        qemu_set_info_str(&s->nc, "can't use file descriptor %s (errno %d)",
+                          addr->u.fd.str, -ret);
+        qapi_free_SocketAddress(addr);
+        goto error;
     }
+    g_assert(ret == 0);
 
-    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
-    s = DO_UPCAST(NetStreamState, nc, nc);
-    s->fd = -1;
-    s->listen_fd = fd;
-    s->nc.link_down = true;
     net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
 
-    qemu_set_fd_handler(s->listen_fd, net_stream_accept, NULL, s);
-    return 0;
+    /* Disable Nagle algorithm on TCP sockets to reduce latency */
+    qio_channel_set_delay(s->ioc, false);
+
+    s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
+                                            s, NULL);
+    s->nc.link_down = false;
+    qapi_free_SocketAddress(addr);
+
+    return;
+error:
+    object_unref(OBJECT(s->ioc));
+    s->ioc = NULL;
 }
 
 static int net_stream_client_init(NetClientState *peer,
@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,
                                   Error **errp)
 {
     NetStreamState *s;
-    struct sockaddr_in saddr_in;
-    struct sockaddr_un saddr_un;
-    int fd, connected, ret;
-
-    switch (addr->type) {
-    case SOCKET_ADDRESS_TYPE_INET:
-        if (convert_host_port(&saddr_in, addr->u.inet.host, addr->u.inet.port,
-                              errp) < 0) {
-            return -1;
-        }
+    NetClientState *nc;
+    QIOChannelSocket *sioc = qio_channel_socket_new();
 
-        fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
-        if (fd < 0) {
-            error_setg_errno(errp, errno, "can't create stream socket");
-            return -1;
-        }
-        qemu_socket_set_nonblock(fd);
-
-        connected = 0;
-        for (;;) {
-            ret = connect(fd, (struct sockaddr *)&saddr_in, sizeof(saddr_in));
-            if (ret < 0) {
-                if (errno == EINTR || errno == EWOULDBLOCK) {
-                    /* continue */
-                } else if (errno == EINPROGRESS ||
-                           errno == EALREADY) {
-                    break;
-                } else {
-                    error_setg_errno(errp, errno, "can't connect socket");
-                    closesocket(fd);
-                    return -1;
-                }
-            } else {
-                connected = 1;
-                break;
-            }
-        }
-        break;
-    case SOCKET_ADDRESS_TYPE_UNIX:
-        saddr_un.sun_family = PF_UNIX;
-        ret = snprintf(saddr_un.sun_path, sizeof(saddr_un.sun_path), "%s",
-                       addr->u.q_unix.path);
-        if (ret < 0 || ret >= sizeof(saddr_un.sun_path)) {
-            error_setg(errp, "UNIX socket path '%s' is too long",
-                       addr->u.q_unix.path);
-            error_append_hint(errp, "Path must be less than %zu bytes\n",
-                              sizeof(saddr_un.sun_path));
-            return -1;
-        }
+    nc = qemu_new_net_client(&net_stream_info, peer, model, name);
+    s = DO_UPCAST(NetStreamState, nc, nc);
 
-        fd = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
-        if (fd < 0) {
-            error_setg_errno(errp, errno, "can't create stream socket");
-            return -1;
-        }
-        qemu_socket_set_nonblock(fd);
-
-        connected = 0;
-        for (;;) {
-            ret = connect(fd, (struct sockaddr *)&saddr_un, sizeof(saddr_un));
-            if (ret < 0) {
-                if (errno == EINTR || errno == EWOULDBLOCK) {
-                    /* continue */
-                } else if (errno == EAGAIN ||
-                           errno == EALREADY) {
-                    break;
-                } else {
-                    error_setg_errno(errp, errno, "can't connect socket");
-                    closesocket(fd);
-                    return -1;
-                }
-            } else {
-                connected = 1;
-                break;
-            }
-        }
-        break;
-    case SOCKET_ADDRESS_TYPE_FD:
-        fd = monitor_fd_param(monitor_cur(), addr->u.fd.str, errp);
-        if (fd == -1) {
-            return -1;
-        }
-        ret = qemu_socket_try_set_nonblock(fd);
-        if (ret < 0) {
-            error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d",
-                             name, fd);
-            return -1;
-        }
-        connected = 1;
-        break;
-    default:
-        error_setg(errp, "only support inet, unix or fd type");
-        return -1;
-    }
+    s->ioc = QIO_CHANNEL(sioc);
+    s->nc.link_down = true;
+
+    qio_channel_socket_connect_async(sioc, addr,
+                                     net_stream_client_connected, s,
+                                     NULL, NULL);
 
-    s = net_stream_fd_init(peer, model, name, fd, connected);
-
-    switch (addr->type) {
-    case SOCKET_ADDRESS_TYPE_INET:
-        qemu_set_info_str(&s->nc, "connect to %s:%d",
-                          inet_ntoa(saddr_in.sin_addr),
-                          ntohs(saddr_in.sin_port));
-        break;
-    case SOCKET_ADDRESS_TYPE_UNIX:
-        qemu_set_info_str(&s->nc, " connect to %s", saddr_un.sun_path);
-        break;
-    case SOCKET_ADDRESS_TYPE_FD:
-        qemu_set_info_str(&s->nc, "connect to fd %d", fd);
-        break;
-    default:
-        g_assert_not_reached();
-    }
     return 0;
 }
 
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
     "-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"
     "                configure a network backend to connect to another network\n"
     "                using an UDP tunnel\n"
-    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port\n"
-    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path\n"
+    "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port[,to=maxport][,numeric=on|off][,keep-alive=on|off][,mptcp=on|off][,addr.ipv4=on|off][,addr.ipv6=on|off]\n"
+    "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path[,abstract=on|off][,tight=on|off]\n"
     "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"
     "                configure a network backend to connect to another network\n"
     "                using a socket connection in stream mode.\n"
-- 
2.7.4

From: Laurent Vivier <lvivier@redhat.com>

The netdev reports NETDEV_STREAM_CONNECTED event when the backend
is connected, and NETDEV_STREAM_DISCONNECTED when it is disconnected.

The NETDEV_STREAM_CONNECTED event includes the destination address.

This allows a system manager like libvirt to detect when the server
fails.

For instance with passt:

{ 'execute': 'qmp_capabilities' }
{ "return": { } }
{ "timestamp": { "seconds": 1666341395, "microseconds": 505347 },
    "event": "NETDEV_STREAM_CONNECTED",
    "data": { "netdev-id": "netdev0",
        "addr": { "path": "/tmp/passt_1.socket", "type": "unix" } } }

[killing passt here]

{ "timestamp": { "seconds": 1666341430, "microseconds": 968694 },
    "event": "NETDEV_STREAM_DISCONNECTED",
    "data": { "netdev-id": "netdev0" } }

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/stream.c  |  5 +++++
 qapi/net.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/net/stream.c b/net/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/net/stream.c
+++ b/net/stream.c
@@ -XXX,XX +XXX,XX @@
 #include "io/channel.h"
 #include "io/channel-socket.h"
 #include "io/net-listener.h"
+#include "qapi/qapi-events-net.h"
 
 typedef struct NetStreamState {
     NetClientState nc;
@@ -XXX,XX +XXX,XX @@ static gboolean net_stream_send(QIOChannel *ioc,
         s->nc.link_down = true;
         qemu_set_info_str(&s->nc, "");
 
+        qapi_event_send_netdev_stream_disconnected(s->nc.name);
+
         return G_SOURCE_REMOVE;
     }
     buf = buf1;
@@ -XXX,XX +XXX,XX @@ static void net_stream_listen(QIONetListener *listener,
     uri = socket_uri(addr);
     qemu_set_info_str(&s->nc, uri);
     g_free(uri);
+    qapi_event_send_netdev_stream_connected(s->nc.name, addr);
     qapi_free_SocketAddress(addr);
 }
 
@@ -XXX,XX +XXX,XX @@ static void net_stream_client_connected(QIOTask *task, gpointer opaque)
     s->ioc_read_tag = qio_channel_add_watch(s->ioc, G_IO_IN, net_stream_send,
                                             s, NULL);
     s->nc.link_down = false;
+    qapi_event_send_netdev_stream_connected(s->nc.name, addr);
     qapi_free_SocketAddress(addr);
 
     return;
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': 'FAILOVER_NEGOTIATED',
   'data': {'device-id': 'str'} }
+
+##
+# @NETDEV_STREAM_CONNECTED:
+#
+# Emitted when the netdev stream backend is connected
+#
+# @netdev-id: QEMU netdev id that is connected
+# @addr: The destination address
+#
+# Since: 7.2
+#
+# Example:
+#
+# <- { "event": "NETDEV_STREAM_CONNECTED",
+#      "data": { "netdev-id": "netdev0",
+#                "addr": { "port": "47666", "ipv6": true,
+#                          "host": "::1", "type": "inet" } },
+#      "timestamp": { "seconds": 1666269863, "microseconds": 311222 } }
+#
+# or
+#
+# <- { "event": "NETDEV_STREAM_CONNECTED",
+#      "data": { "netdev-id": "netdev0",
+#                "addr": { "path": "/tmp/qemu0", "type": "unix" } },
+#      "timestamp": { "seconds": 1666269706, "microseconds": 413651 } }
+#
+##
+{ 'event': 'NETDEV_STREAM_CONNECTED',
+  'data': { 'netdev-id': 'str',
+            'addr': 'SocketAddress' } }
+
+##
+# @NETDEV_STREAM_DISCONNECTED:
+#
+# Emitted when the netdev stream backend is disconnected
+#
+# @netdev-id: QEMU netdev id that is disconnected
+#
+# Since: 7.2
+#
+# Example:
+#
+# <- { 'event': 'NETDEV_STREAM_DISCONNECTED',
+#      'data': {'netdev-id': 'netdev0'},
+#      'timestamp': {'seconds': 1663330937, 'microseconds': 526695} }
+#
+##
+{ 'event': 'NETDEV_STREAM_DISCONNECTED',
+  'data': { 'netdev-id': 'str' } }
-- 
2.7.4