Series comparison

-[Qemu-devel] [PULL 0/5] Net patches
+[PULL 0/8] Net patches
-The following changes since commit 5dae13cd71f0755a1395b5a4cde635b8a6ee3f58:
+The following changes since commit eec398119fc6911d99412c37af06a6bc27871f85:
-  Merge remote-tracking branch 'remotes/rth/tags/pull-or-20170214' into staging (2017-02-14 09:55:48 +0000)
+  Merge tag 'for_upstream' of git://git.kernel.org/pub/scm/virt/kvm/mst/qemu into staging (2022-05-16 16:31:01 -0700)
 are available in the git repository at:
   https://github.com/jasowang/qemu.git tags/net-pull-request
-for you to fetch changes up to 4154c7e03fa55b4cf52509a83d50d6c09d743b77:
+for you to fetch changes up to 052c2579b89b0d87debe8b05594b5180f0fde87d:
-  net: e1000e: fix an infinite loop issue (2017-02-15 11:18:57 +0800)
+  tulip: Assign default MAC address if not specified (2022-05-17 16:48:23 +0800)
 ----------------------------------------------------------------
 ----------------------------------------------------------------
-Li Qiang (1):
+Helge Deller (1):
-      net: e1000e: fix an infinite loop issue
+      tulip: Assign default MAC address if not specified
-Paolo Bonzini (1):
+Vladislav Yaroshchuk (7):
-      net: e1000e: fix dead code in e1000e_write_packet_to_guest
+      net/vmnet: add vmnet dependency and customizable option
       net/vmnet: add vmnet backends to qapi/net
       net/vmnet: implement shared mode (vmnet-shared)
       net/vmnet: implement host mode (vmnet-host)
       net/vmnet: implement bridged mode (vmnet-bridged)
       net/vmnet: update qemu-options.hx
       net/vmnet: update hmp-commands.hx
-Prasad J Pandit (1):
+ hmp-commands.hx               |   6 +-
-      net: imx: limit buffer descriptor count
+ hw/net/tulip.c                |   4 +-
+ meson.build                   |  16 +-
-Thomas Huth (1):
+ meson_options.txt             |   2 +
-      net: Mark 'vlan' parameter as deprecated
+ net/clients.h                 |  11 ++
+ net/meson.build               |   7 +
-Zhang Chen (1):
+ net/net.c                     |  10 ++
-      colo-compare: sort TCP packet queue by sequence number
+ net/vmnet-bridged.m           | 152 +++++++++++++++++
+ net/vmnet-common.m            | 378 ++++++++++++++++++++++++++++++++++++++++++
- hw/net/e1000e_core.c |  9 +++++++--
+ net/vmnet-host.c              | 128 ++++++++++++++
- hw/net/imx_fec.c     | 10 ++++++----
+ net/vmnet-shared.c            | 114 +++++++++++++
- net/colo-compare.c   | 19 +++++++++++++++++++
+ net/vmnet_int.h               |  63 +++++++
- net/net.c            |  6 ++++++
+ qapi/net.json                 | 133 ++++++++++++++-
-files changed, 38 insertions(+), 6 deletions(-)
+ qemu-options.hx               |  25 +++
+ scripts/meson-buildoptions.sh |   1 +
+files changed, 1044 insertions(+), 6 deletions(-)
  create mode 100644 net/vmnet-bridged.m
  create mode 100644 net/vmnet-common.m
  create mode 100644 net/vmnet-host.c
  create mode 100644 net/vmnet-shared.c
  create mode 100644 net/vmnet_int.h

-New patch
+[PULL 1/8] net/vmnet: add vmnet dependency and customizable option
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+vmnet.framework dependency is added with 'vmnet' option
+to enable or disable it. Default value is 'auto'.
+used vmnet features are available since macOS 11.0,
+but new backend can be built and work properly with
+subset of them on 10.15 too.
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ meson.build                   | 16 +++++++++++++++-
+ meson_options.txt             |  2 ++
+ scripts/meson-buildoptions.sh |  1 +
+files changed, 18 insertions(+), 1 deletion(-)
+diff --git a/meson.build b/meson.build
+index XXXXXXX..XXXXXXX 100644
+--- a/meson.build
++++ b/meson.build
+@@ -XXX,XX +XXX,XX @@ if cocoa.found() and get_option('gtk').enabled()
+   error('Cocoa and GTK+ cannot be enabled at the same time')
+ endif
++vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
++if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
++                                              'VMNET_BRIDGED_MODE',
++                                              dependencies: vmnet)
++  vmnet = not_found
++  if get_option('vmnet').enabled()
++    error('vmnet.framework API is outdated')
++  else
++    warning('vmnet.framework API is outdated, disabling')
++  endif
++endif
++
+ seccomp = not_found
+ if not get_option('seccomp').auto() or have_system or have_tools
+   seccomp = dependency('libseccomp', version: '>=2.3.0',
+@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
+ config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
+ config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
+ config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
++config_host_data.set('CONFIG_VMNET', vmnet.found())
+ config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
+ config_host_data.set('CONFIG_PNG', png.found())
+ config_host_data.set('CONFIG_VNC', vnc.found())
+@@ -XXX,XX +XXX,XX @@ summary(summary_info, bool_yn: true, section: 'Crypto')
+ # Libraries
+ summary_info = {}
+ if targetos == 'darwin'
+-  summary_info += {'Cocoa support':   cocoa}
++  summary_info += {'Cocoa support':           cocoa}
++  summary_info += {'vmnet.framework support': vmnet}
+ endif
+ summary_info += {'SDL support':       sdl}
+ summary_info += {'SDL image support': sdl_image}
+diff --git a/meson_options.txt b/meson_options.txt
+index XXXXXXX..XXXXXXX 100644
+--- a/meson_options.txt
++++ b/meson_options.txt
+@@ -XXX,XX +XXX,XX @@ option('netmap', type : 'feature', value : 'auto',
+        description: 'netmap network backend support')
+ option('vde', type : 'feature', value : 'auto',
+        description: 'vde network backend support')
++option('vmnet', type : 'feature', value : 'auto',
++       description: 'vmnet.framework network backend support')
+ option('virglrenderer', type : 'feature', value : 'auto',
+        description: 'virgl rendering support')
+ option('png', type : 'feature', value : 'auto',
+diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
+index XXXXXXX..XXXXXXX 100644
+--- a/scripts/meson-buildoptions.sh
++++ b/scripts/meson-buildoptions.sh
+@@ -XXX,XX +XXX,XX @@ meson_options_help() {
+   printf "%s\n" '  vhost-kernel    vhost kernel backend support'
+   printf "%s\n" '  vhost-net       vhost-net kernel acceleration support'
+   printf "%s\n" '  vhost-user      vhost-user backend support'
++  printf "%s\n" '  vmnet           vmnet.framework network backend support'
+   printf "%s\n" '  vhost-user-blk-server'
+   printf "%s\n" '                  build vhost-user-blk server'
+   printf "%s\n" '  vhost-vdpa      vhost-vdpa kernel backend support'
+--
+.25.1

-[Qemu-devel] [PULL 1/5] net: Mark 'vlan' parameter as deprecated
+[PULL 2/8] net/vmnet: add vmnet backends to qapi/net
-From: Thomas Huth <thuth@redhat.com>
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
-The 'vlan' parameter is a continuous source of confusion for the users,
+Create separate netdevs for each vmnet operating mode:
-many people mix it up with the more common term VLAN (the link layer
+- vmnet-host
-packet encapsulation), and even if they realize that the QEMU 'vlan' is
+- vmnet-shared
-rather some kind of network hub emulation, there is still a high risk
+- vmnet-bridged
 that they configure their QEMU networking in a wrong way with this
 parameter (e.g. by hooking NICs together, so they get a 'loopback'
 between one and the other NIC).
 Thus at one point in time, we should finally get rid of the 'vlan'
 feature in QEMU. Let's do a first step in this direction by declaring
 the 'vlan' parameter as deprecated and informing the users to use the
 'netdev' parameter instead.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/net.c | 6 ++++++
+ net/clients.h       |  11 ++++
-file changed, 6 insertions(+)
+ net/meson.build     |   7 +++
  net/net.c           |  10 ++++
  net/vmnet-bridged.m |  25 +++++++++
  net/vmnet-common.m  |  19 +++++++
  net/vmnet-host.c    |  24 ++++++++
  net/vmnet-shared.c  |  25 +++++++++
  net/vmnet_int.h     |  25 +++++++++
  qapi/net.json       | 133 +++++++++++++++++++++++++++++++++++++++++++-
 files changed, 277 insertions(+), 2 deletions(-)
  create mode 100644 net/vmnet-bridged.m
  create mode 100644 net/vmnet-common.m
  create mode 100644 net/vmnet-host.c
  create mode 100644 net/vmnet-shared.c
  create mode 100644 net/vmnet_int.h
+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_vhost_user(const Netdev *netdev, const char *name,
+ int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
+                         NetClientState *peer, Error **errp);
++#ifdef CONFIG_VMNET
++int net_init_vmnet_host(const Netdev *netdev, const char *name,
++                          NetClientState *peer, Error **errp);
++
++int net_init_vmnet_shared(const Netdev *netdev, const char *name,
++                          NetClientState *peer, Error **errp);
++
++int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
++                          NetClientState *peer, Error **errp);
++#endif /* CONFIG_VMNET */
++
+ #endif /* QEMU_NET_CLIENTS_H */
+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 @@ if have_vhost_net_vdpa
+   softmmu_ss.add(files('vhost-vdpa.c'))
+ endif
++vmnet_files = files(
++  'vmnet-common.m',
++  'vmnet-bridged.m',
++  'vmnet-host.c',
++  'vmnet-shared.c'
++)
++softmmu_ss.add(when: vmnet, if_true: vmnet_files)
+ subdir('can')
 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 @@ static int (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
-     const Netdev *netdev;
+ #ifdef CONFIG_L2TPV3
-     const char *name;
+         [NET_CLIENT_DRIVER_L2TPV3]    = net_init_l2tpv3,
-     NetClientState *peer = NULL;
+ #endif
-+    static bool vlan_warned;
++#ifdef CONFIG_VMNET
++        [NET_CLIENT_DRIVER_VMNET_HOST] = net_init_vmnet_host,
-     if (is_netdev) {
++        [NET_CLIENT_DRIVER_VMNET_SHARED] = net_init_vmnet_shared,
-         netdev = object;
++        [NET_CLIENT_DRIVER_VMNET_BRIDGED] = net_init_vmnet_bridged,
-@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp)
++#endif /* CONFIG_VMNET */
-             !opts->u.nic.data->has_netdev) {
+ };
-             peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL);
-         }
-+
+@@ -XXX,XX +XXX,XX @@ void show_netdevs(void)
-+        if (net->has_vlan && !vlan_warned) {
+ #endif
-+            error_report("'vlan' is deprecated. Please use 'netdev' instead.");
+ #ifdef CONFIG_VHOST_VDPA
-+            vlan_warned = true;
+         "vhost-vdpa",
-+        }
++#endif
-     }
++#ifdef CONFIG_VMNET
++        "vmnet-host",
-     if (net_client_init_fun[netdev->type](netdev, name, peer, errp) < 0) {
++        "vmnet-shared",
 +        "vmnet-bridged",
  #endif
      };
 diff --git a/net/vmnet-bridged.m b/net/vmnet-bridged.m
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/vmnet-bridged.m
@@ -XXX,XX +XXX,XX @@
 +/*
 + * vmnet-bridged.m
 + *
 + * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qapi/qapi-types-net.h"
 +#include "vmnet_int.h"
 +#include "clients.h"
 +#include "qemu/error-report.h"
 +#include "qapi/error.h"
 +
 +#include <vmnet/vmnet.h>
 +
 +int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
 +                           NetClientState *peer, Error **errp)
 +{
 +  error_setg(errp, "vmnet-bridged is not implemented yet");
 +  return -1;
 +}
 diff --git a/net/vmnet-common.m b/net/vmnet-common.m
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/vmnet-common.m
@@ -XXX,XX +XXX,XX @@
 +/*
 + * vmnet-common.m - network client wrapper for Apple vmnet.framework
 + *
 + * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
 + * Copyright(c) 2021 Phillip Tennen <phillip@axleos.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qapi/qapi-types-net.h"
 +#include "vmnet_int.h"
 +#include "clients.h"
 +#include "qemu/error-report.h"
 +#include "qapi/error.h"
 +
 +#include <vmnet/vmnet.h>
 diff --git a/net/vmnet-host.c b/net/vmnet-host.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/vmnet-host.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * vmnet-host.c
 + *
 + * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qapi/qapi-types-net.h"
 +#include "vmnet_int.h"
 +#include "clients.h"
 +#include "qemu/error-report.h"
 +#include "qapi/error.h"
 +
 +#include <vmnet/vmnet.h>
 +
 +int net_init_vmnet_host(const Netdev *netdev, const char *name,
 +                        NetClientState *peer, Error **errp) {
 +  error_setg(errp, "vmnet-host is not implemented yet");
 +  return -1;
 +}
 diff --git a/net/vmnet-shared.c b/net/vmnet-shared.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/vmnet-shared.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * vmnet-shared.c
 + *
 + * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qapi/qapi-types-net.h"
 +#include "vmnet_int.h"
 +#include "clients.h"
 +#include "qemu/error-report.h"
 +#include "qapi/error.h"
 +
 +#include <vmnet/vmnet.h>
 +
 +int net_init_vmnet_shared(const Netdev *netdev, const char *name,
 +                          NetClientState *peer, Error **errp)
 +{
 +  error_setg(errp, "vmnet-shared is not implemented yet");
 +  return -1;
 +}
 diff --git a/net/vmnet_int.h b/net/vmnet_int.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/net/vmnet_int.h
@@ -XXX,XX +XXX,XX @@
 +/*
 + * vmnet_int.h
 + *
 + * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + *
 + */
 +#ifndef VMNET_INT_H
 +#define VMNET_INT_H
 +
 +#include "qemu/osdep.h"
 +#include "vmnet_int.h"
 +#include "clients.h"
 +
 +#include <vmnet/vmnet.h>
 +
 +typedef struct VmnetState {
 +  NetClientState nc;
 +
 +} VmnetState;
 +
 +
 +#endif /* VMNET_INT_H */
 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':     'str',
      '*queues':       'int' } }
 +##
 +# @NetdevVmnetHostOptions:
 +#
 +# vmnet (host mode) network backend.
 +#
 +# Allows the vmnet interface to communicate with other vmnet
 +# interfaces that are in host mode and also with the host.
 +#
 +# @start-address: The starting IPv4 address to use for the interface.
 +#                 Must be in the private IP range (RFC 1918). Must be
 +#                 specified along with @end-address and @subnet-mask.
 +#                 This address is used as the gateway address. The
 +#                 subsequent address up to and including end-address are
 +#                 placed in the DHCP pool.
 +#
 +# @end-address: The DHCP IPv4 range end address to use for the
 +#               interface. Must be in the private IP range (RFC 1918).
 +#               Must be specified along with @start-address and
 +#               @subnet-mask.
 +#
 +# @subnet-mask: The IPv4 subnet mask to use on the interface. Must
 +#               be specified along with @start-address and @subnet-mask.
 +#
 +# @isolated: Enable isolation for this interface. Interface isolation
 +#            ensures that vmnet interface is not able to communicate
 +#            with any other vmnet interfaces. Only communication with
 +#            host is allowed. Requires at least macOS Big Sur 11.0.
 +#
 +# @net-uuid: The identifier (UUID) to uniquely identify the isolated
 +#            network vmnet interface should be added to. If
 +#            set, no DHCP service is provided for this interface and
 +#            network communication is allowed only with other interfaces
 +#            added to this network identified by the UUID. Requires
 +#            at least macOS Big Sur 11.0.
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'NetdevVmnetHostOptions',
 +  'data': {
 +    '*start-address': 'str',
 +    '*end-address':   'str',
 +    '*subnet-mask':   'str',
 +    '*isolated':      'bool',
 +    '*net-uuid':      'str' },
 +  'if': 'CONFIG_VMNET' }
 +
 +##
 +# @NetdevVmnetSharedOptions:
 +#
 +# vmnet (shared mode) network backend.
 +#
 +# Allows traffic originating from the vmnet interface to reach the
 +# Internet through a network address translator (NAT).
 +# The vmnet interface can communicate with the host and with
 +# other shared mode interfaces on the same subnet. If no DHCP
 +# settings, subnet mask and IPv6 prefix specified, the interface can
 +# communicate with any of other interfaces in shared mode.
 +#
 +# @start-address: The starting IPv4 address to use for the interface.
 +#                 Must be in the private IP range (RFC 1918). Must be
 +#                 specified along with @end-address and @subnet-mask.
 +#                 This address is used as the gateway address. The
 +#                 subsequent address up to and including end-address are
 +#                 placed in the DHCP pool.
 +#
 +# @end-address: The DHCP IPv4 range end address to use for the
 +#               interface. Must be in the private IP range (RFC 1918).
 +#               Must be specified along with @start-address and @subnet-mask.
 +#
 +# @subnet-mask: The IPv4 subnet mask to use on the interface. Must
 +#                be specified along with @start-address and @subnet-mask.
 +#
 +# @isolated: Enable isolation for this interface. Interface isolation
 +#            ensures that vmnet interface is not able to communicate
 +#            with any other vmnet interfaces. Only communication with
 +#            host is allowed. Requires at least macOS Big Sur 11.0.
 +#
 +# @nat66-prefix: The IPv6 prefix to use into guest network. Must be a
 +#                unique local address i.e. start with fd00::/8 and have
 +#                length of 64.
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'NetdevVmnetSharedOptions',
 +  'data': {
 +    '*start-address': 'str',
 +    '*end-address':   'str',
 +    '*subnet-mask':   'str',
 +    '*isolated':      'bool',
 +    '*nat66-prefix':  'str' },
 +  'if': 'CONFIG_VMNET' }
 +
 +##
 +# @NetdevVmnetBridgedOptions:
 +#
 +# vmnet (bridged mode) network backend.
 +#
 +# Bridges the vmnet interface with a physical network interface.
 +#
 +# @ifname: The name of the physical interface to be bridged.
 +#
 +# @isolated: Enable isolation for this interface. Interface isolation
 +#            ensures that vmnet interface is not able to communicate
 +#            with any other vmnet interfaces. Only communication with
 +#            host is allowed. Requires at least macOS Big Sur 11.0.
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'NetdevVmnetBridgedOptions',
 +  'data': {
 +    'ifname':     'str',
 +    '*isolated':  'bool' },
 +  'if': 'CONFIG_VMNET' }
 +
  ##
  # @NetClientDriver:
  #
@@ -XXX,XX +XXX,XX @@
  # Since: 2.7
  #
  #        @vhost-vdpa since 5.1
 +#        @vmnet-host since 7.1
 +#        @vmnet-shared since 7.1
 +#        @vmnet-bridged since 7.1
  ##
  { 'enum': 'NetClientDriver',
    'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'vde',
 -            'bridge', 'hubport', 'netmap', 'vhost-user', 'vhost-vdpa' ] }
 +            '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' }] }
  ##
  # @Netdev:
@@ -XXX,XX +XXX,XX @@
  # Since: 1.2
  #
  #        'l2tpv3' - since 2.1
 +#        'vmnet-host' - since 7.1
 +#        'vmnet-shared' - since 7.1
 +#        'vmnet-bridged' - since 7.1
  ##
  { 'union': 'Netdev',
    'base': { 'id': 'str', 'type': 'NetClientDriver' },
@@ -XXX,XX +XXX,XX @@
      'hubport':  'NetdevHubPortOptions',
      'netmap':   'NetdevNetmapOptions',
      'vhost-user': 'NetdevVhostUserOptions',
 -    'vhost-vdpa': 'NetdevVhostVDPAOptions' } }
 +    'vhost-vdpa': 'NetdevVhostVDPAOptions',
 +    'vmnet-host': { 'type': 'NetdevVmnetHostOptions',
 +                    'if': 'CONFIG_VMNET' },
 +    'vmnet-shared': { 'type': 'NetdevVmnetSharedOptions',
 +                      'if': 'CONFIG_VMNET' },
 +    'vmnet-bridged': { 'type': 'NetdevVmnetBridgedOptions',
 +                       'if': 'CONFIG_VMNET' } } }
  ##
  # @RxState:
 --
-.7.4
+.25.1

-[Qemu-devel] [PULL 5/5] net: e1000e: fix an infinite loop issue
+[PULL 3/8] net/vmnet: implement shared mode (vmnet-shared)
-From: Li Qiang <liq3ea@gmail.com>
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
-This issue is like the issue in e1000 network card addressed in
+Interaction with vmnet.framework in different modes
-this commit:
+differs only on configuration stage, so we can create
-e1000: eliminate infinite loops on out-of-bounds transfer start.
+common `send`, `receive`, etc. procedures and reuse them.
-Signed-off-by: Li Qiang <liqiang6-s@360.cn>
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-Reviewed-by: Dmitry Fleytman <dmitry@daynix.com>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Signed-off-by: Phillip Tennen <phillip@axleos.com>
 Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/e1000e_core.c | 7 ++++++-
+ net/vmnet-common.m | 359 +++++++++++++++++++++++++++++++++++++++++++++
-file changed, 6 insertions(+), 1 deletion(-)
+ net/vmnet-shared.c |  97 +++++++++++-
  net/vmnet_int.h    |  40 ++++-
 files changed, 491 insertions(+), 5 deletions(-)
-diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
+diff --git a/net/vmnet-common.m b/net/vmnet-common.m
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/e1000e_core.c
+--- a/net/vmnet-common.m
-+++ b/hw/net/e1000e_core.c
++++ b/net/vmnet-common.m
-@@ -XXX,XX +XXX,XX @@ typedef struct E1000E_RingInfo_st {
+@@ -XXX,XX +XXX,XX @@
- static inline bool
+  */
- e1000e_ring_empty(E1000ECore *core, const E1000E_RingInfo *r)
- {
+ #include "qemu/osdep.h"
--    return core->mac[r->dh] == core->mac[r->dt];
++#include "qemu/main-loop.h"
-+    return core->mac[r->dh] == core->mac[r->dt] ||
++#include "qemu/log.h"
-+                core->mac[r->dt] >= core->mac[r->dlen] / E1000_RING_DESC_LEN;
+ #include "qapi/qapi-types-net.h"
- }
+ #include "vmnet_int.h"
+ #include "clients.h"
- static inline uint64_t
+@@ -XXX,XX +XXX,XX @@
-@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
+ #include "qapi/error.h"
-             desc_size = core->rx_desc_buf_size;
-         }
+ #include <vmnet/vmnet.h>
++#include <dispatch/dispatch.h>
-+        if (e1000e_ring_empty(core, rxi)) {
++
 +
 +static void vmnet_send_completed(NetClientState *nc, ssize_t len);
 +
 +
 +const char *vmnet_status_map_str(vmnet_return_t status)
 +{
 +    switch (status) {
 +    case VMNET_SUCCESS:
 +        return "success";
 +    case VMNET_FAILURE:
 +        return "general failure (possibly not enough privileges)";
 +    case VMNET_MEM_FAILURE:
 +        return "memory allocation failure";
 +    case VMNET_INVALID_ARGUMENT:
 +        return "invalid argument specified";
 +    case VMNET_SETUP_INCOMPLETE:
 +        return "interface setup is not complete";
 +    case VMNET_INVALID_ACCESS:
 +        return "invalid access, permission denied";
 +    case VMNET_PACKET_TOO_BIG:
 +        return "packet size is larger than MTU";
 +    case VMNET_BUFFER_EXHAUSTED:
 +        return "buffers exhausted in kernel";
 +    case VMNET_TOO_MANY_PACKETS:
 +        return "packet count exceeds limit";
 +#if defined(MAC_OS_VERSION_11_0) && \
 +    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
 +    case VMNET_SHARING_SERVICE_BUSY:
 +        return "conflict, sharing service is in use";
 +#endif
 +    default:
 +        return "unknown vmnet error";
 +    }
 +}
 +
 +
 +/**
 + * Write packets from QEMU to vmnet interface.
 + *
 + * vmnet.framework supports iov, but writing more than
 + * one iov into vmnet interface fails with
 + * 'VMNET_INVALID_ARGUMENT'. Collecting provided iovs into
 + * one and passing it to vmnet works fine. That's the
 + * reason why receive_iov() left unimplemented. But it still
 + * works with good performance having .receive() only.
 + */
 +ssize_t vmnet_receive_common(NetClientState *nc,
 +                             const uint8_t *buf,
 +                             size_t size)
 +{
 +    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
 +    struct vmpktdesc packet;
 +    struct iovec iov;
 +    int pkt_cnt;
 +    vmnet_return_t if_status;
 +
 +    if (size > s->max_packet_size) {
 +        warn_report("vmnet: packet is too big, %zu > %" PRIu64,
 +            packet.vm_pkt_size,
 +            s->max_packet_size);
 +        return -1;
 +    }
 +
 +    iov.iov_base = (char *) buf;
 +    iov.iov_len = size;
 +
 +    packet.vm_pkt_iovcnt = 1;
 +    packet.vm_flags = 0;
 +    packet.vm_pkt_size = size;
 +    packet.vm_pkt_iov = &iov;
 +    pkt_cnt = 1;
 +
 +    if_status = vmnet_write(s->vmnet_if, &packet, &pkt_cnt);
 +    if (if_status != VMNET_SUCCESS) {
 +        error_report("vmnet: write error: %s\n",
 +                     vmnet_status_map_str(if_status));
 +        return -1;
 +    }
 +
 +    if (pkt_cnt) {
 +        return size;
 +    }
 +    return 0;
 +}
 +
 +
 +/**
 + * Read packets from vmnet interface and write them
 + * to temporary buffers in VmnetState.
 + *
 + * Returns read packets number (may be 0) on success,
 + * -1 on error
 + */
 +static int vmnet_read_packets(VmnetState *s)
 +{
 +    assert(s->packets_send_current_pos == s->packets_send_end_pos);
 +
 +    struct vmpktdesc *packets = s->packets_buf;
 +    vmnet_return_t status;
 +    int i;
 +
 +    /* Read as many packets as present */
 +    s->packets_send_current_pos = 0;
 +    s->packets_send_end_pos = VMNET_PACKETS_LIMIT;
 +    for (i = 0; i < s->packets_send_end_pos; ++i) {
 +        packets[i].vm_pkt_size = s->max_packet_size;
 +        packets[i].vm_pkt_iovcnt = 1;
 +        packets[i].vm_flags = 0;
 +    }
 +
 +    status = vmnet_read(s->vmnet_if, packets, &s->packets_send_end_pos);
 +    if (status != VMNET_SUCCESS) {
 +        error_printf("vmnet: read failed: %s\n",
 +                     vmnet_status_map_str(status));
 +        s->packets_send_current_pos = 0;
 +        s->packets_send_end_pos = 0;
 +        return -1;
 +    }
 +    return s->packets_send_end_pos;
 +}
 +
 +
 +/**
 + * Write packets from temporary buffers in VmnetState
 + * to QEMU.
 + */
 +static void vmnet_write_packets_to_qemu(VmnetState *s)
 +{
 +    while (s->packets_send_current_pos < s->packets_send_end_pos) {
 +        ssize_t size = qemu_send_packet_async(&s->nc,
 +                                      s->iov_buf[s->packets_send_current_pos].iov_base,
 +                                      s->packets_buf[s->packets_send_current_pos].vm_pkt_size,
 +                                      vmnet_send_completed);
 +
 +        if (size == 0) {
 +            /* QEMU is not ready to consume more packets -
 +             * stop and wait for completion callback call */
 +            return;
 +        }
-+
++        ++s->packets_send_current_pos;
-         base = e1000e_ring_head_descr(core, rxi);
++    }
++}
-         pci_dma_read(d, base, &desc, core->rx_desc_len);
++
 +
 +/**
 + * Bottom half callback that transfers packets from vmnet interface
 + * to QEMU.
 + *
 + * The process of transferring packets is three-staged:
 + * 1. Handle vmnet event;
 + * 2. Read packets from vmnet interface into temporary buffer;
 + * 3. Write packets from temporary buffer to QEMU.
 + *
 + * QEMU may suspend this process on the last stage, returning 0 from
 + * qemu_send_packet_async function. If this happens, we should
 + * respectfully wait until it is ready to consume more packets,
 + * write left ones in temporary buffer and only after this
 + * continue reading more packets from vmnet interface.
 + *
 + * Packets to be transferred are stored into packets_buf,
 + * in the window [packets_send_current_pos..packets_send_end_pos)
 + * including current_pos, excluding end_pos.
 + *
 + * Thus, if QEMU is not ready, buffer is not read and
 + * packets_send_current_pos < packets_send_end_pos.
 + */
 +static void vmnet_send_bh(void *opaque)
 +{
 +    NetClientState *nc = (NetClientState *) opaque;
 +    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
 +
 +    /*
 +     * Do nothing if QEMU is not ready - wait
 +     * for completion callback invocation
 +     */
 +    if (s->packets_send_current_pos < s->packets_send_end_pos) {
 +        return;
 +    }
 +
 +    /* Read packets from vmnet interface */
 +    if (vmnet_read_packets(s) > 0) {
 +        /* Send them to QEMU */
 +        vmnet_write_packets_to_qemu(s);
 +    }
 +}
 +
 +
 +/**
 + * Completion callback to be invoked by QEMU when it becomes
 + * ready to consume more packets.
 + */
 +static void vmnet_send_completed(NetClientState *nc, ssize_t len)
 +{
 +    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
 +
 +    /* Callback is invoked eq queued packet is sent */
 +    ++s->packets_send_current_pos;
 +
 +    /* Complete sending packets left in VmnetState buffers */
 +    vmnet_write_packets_to_qemu(s);
 +
 +    /* And read new ones from vmnet if VmnetState buffer is ready */
 +    if (s->packets_send_current_pos < s->packets_send_end_pos) {
 +        qemu_bh_schedule(s->send_bh);
 +    }
 +}
 +
 +
 +static void vmnet_bufs_init(VmnetState *s)
 +{
 +    struct vmpktdesc *packets = s->packets_buf;
 +    struct iovec *iov = s->iov_buf;
 +    int i;
 +
 +    for (i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
 +        iov[i].iov_len = s->max_packet_size;
 +        iov[i].iov_base = g_malloc0(iov[i].iov_len);
 +        packets[i].vm_pkt_iov = iov + i;
 +    }
 +}
 +
 +
 +int vmnet_if_create(NetClientState *nc,
 +                    xpc_object_t if_desc,
 +                    Error **errp)
 +{
 +    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
 +    dispatch_semaphore_t if_created_sem = dispatch_semaphore_create(0);
 +    __block vmnet_return_t if_status;
 +
 +    s->if_queue = dispatch_queue_create(
 +        "org.qemu.vmnet.if_queue",
 +        DISPATCH_QUEUE_SERIAL
 +    );
 +
 +    xpc_dictionary_set_bool(
 +        if_desc,
 +        vmnet_allocate_mac_address_key,
 +        false
 +    );
 +
 +#ifdef DEBUG
 +    qemu_log("vmnet.start.interface_desc:\n");
 +    xpc_dictionary_apply(if_desc,
 +                         ^bool(const char *k, xpc_object_t v) {
 +                             char *desc = xpc_copy_description(v);
 +                             qemu_log("  %s=%s\n", k, desc);
 +                             free(desc);
 +                             return true;
 +                         });
 +#endif /* DEBUG */
 +
 +    s->vmnet_if = vmnet_start_interface(
 +        if_desc,
 +        s->if_queue,
 +        ^(vmnet_return_t status, xpc_object_t interface_param) {
 +            if_status = status;
 +            if (status != VMNET_SUCCESS || !interface_param) {
 +                dispatch_semaphore_signal(if_created_sem);
 +                return;
 +            }
 +
 +#ifdef DEBUG
 +            qemu_log("vmnet.start.interface_param:\n");
 +            xpc_dictionary_apply(interface_param,
 +                                 ^bool(const char *k, xpc_object_t v) {
 +                                     char *desc = xpc_copy_description(v);
 +                                     qemu_log("  %s=%s\n", k, desc);
 +                                     free(desc);
 +                                     return true;
 +                                 });
 +#endif /* DEBUG */
 +
 +            s->mtu = xpc_dictionary_get_uint64(
 +                interface_param,
 +                vmnet_mtu_key);
 +            s->max_packet_size = xpc_dictionary_get_uint64(
 +                interface_param,
 +                vmnet_max_packet_size_key);
 +
 +            dispatch_semaphore_signal(if_created_sem);
 +        });
 +
 +    if (s->vmnet_if == NULL) {
 +        dispatch_release(s->if_queue);
 +        dispatch_release(if_created_sem);
 +        error_setg(errp,
 +                   "unable to create interface with requested params");
 +        return -1;
 +    }
 +
 +    dispatch_semaphore_wait(if_created_sem, DISPATCH_TIME_FOREVER);
 +    dispatch_release(if_created_sem);
 +
 +    if (if_status != VMNET_SUCCESS) {
 +        dispatch_release(s->if_queue);
 +        error_setg(errp,
 +                   "cannot create vmnet interface: %s",
 +                   vmnet_status_map_str(if_status));
 +        return -1;
 +    }
 +
 +    s->send_bh = aio_bh_new(qemu_get_aio_context(), vmnet_send_bh, nc);
 +    vmnet_bufs_init(s);
 +
 +    s->packets_send_current_pos = 0;
 +    s->packets_send_end_pos = 0;
 +
 +    vmnet_interface_set_event_callback(
 +        s->vmnet_if,
 +        VMNET_INTERFACE_PACKETS_AVAILABLE,
 +        s->if_queue,
 +        ^(interface_event_t event_id, xpc_object_t event) {
 +            assert(event_id == VMNET_INTERFACE_PACKETS_AVAILABLE);
 +            /*
 +             * This function is being called from a non qemu thread, so
 +             * we only schedule a BH, and do the rest of the io completion
 +             * handling from vmnet_send_bh() which runs in a qemu context.
 +             */
 +            qemu_bh_schedule(s->send_bh);
 +        });
 +
 +    return 0;
 +}
 +
 +
 +void vmnet_cleanup_common(NetClientState *nc)
 +{
 +    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
 +    dispatch_semaphore_t if_stopped_sem;
 +
 +    if (s->vmnet_if == NULL) {
 +        return;
 +    }
 +
 +    if_stopped_sem = dispatch_semaphore_create(0);
 +    vmnet_stop_interface(
 +        s->vmnet_if,
 +        s->if_queue,
 +        ^(vmnet_return_t status) {
 +            assert(status == VMNET_SUCCESS);
 +            dispatch_semaphore_signal(if_stopped_sem);
 +        });
 +    dispatch_semaphore_wait(if_stopped_sem, DISPATCH_TIME_FOREVER);
 +
 +    qemu_purge_queued_packets(nc);
 +
 +    qemu_bh_delete(s->send_bh);
 +    dispatch_release(if_stopped_sem);
 +    dispatch_release(s->if_queue);
 +
 +    for (int i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
 +        g_free(s->iov_buf[i].iov_base);
 +    }
 +}
 diff --git a/net/vmnet-shared.c b/net/vmnet-shared.c
 index XXXXXXX..XXXXXXX 100644
 --- a/net/vmnet-shared.c
 +++ b/net/vmnet-shared.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qapi/qapi-types-net.h"
 +#include "qapi/error.h"
  #include "vmnet_int.h"
  #include "clients.h"
 -#include "qemu/error-report.h"
 -#include "qapi/error.h"
  #include <vmnet/vmnet.h>
 +
 +static bool validate_options(const Netdev *netdev, Error **errp)
 +{
 +    const NetdevVmnetSharedOptions *options = &(netdev->u.vmnet_shared);
 +
 +#if !defined(MAC_OS_VERSION_11_0) || \
 +    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_11_0
 +    if (options->has_isolated) {
 +        error_setg(errp,
 +                   "vmnet-shared.isolated feature is "
 +                   "unavailable: outdated vmnet.framework API");
 +        return false;
 +    }
 +#endif
 +
 +    if ((options->has_start_address ||
 +         options->has_end_address ||
 +         options->has_subnet_mask) &&
 +        !(options->has_start_address &&
 +          options->has_end_address &&
 +          options->has_subnet_mask)) {
 +        error_setg(errp,
 +                   "'start-address', 'end-address', 'subnet-mask' "
 +                   "should be provided together"
 +        );
 +        return false;
 +    }
 +
 +    return true;
 +}
 +
 +static xpc_object_t build_if_desc(const Netdev *netdev)
 +{
 +    const NetdevVmnetSharedOptions *options = &(netdev->u.vmnet_shared);
 +    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
 +
 +    xpc_dictionary_set_uint64(
 +        if_desc,
 +        vmnet_operation_mode_key,
 +        VMNET_SHARED_MODE
 +    );
 +
 +    if (options->has_nat66_prefix) {
 +        xpc_dictionary_set_string(if_desc,
 +                                  vmnet_nat66_prefix_key,
 +                                  options->nat66_prefix);
 +    }
 +
 +    if (options->has_start_address) {
 +        xpc_dictionary_set_string(if_desc,
 +                                  vmnet_start_address_key,
 +                                  options->start_address);
 +        xpc_dictionary_set_string(if_desc,
 +                                  vmnet_end_address_key,
 +                                  options->end_address);
 +        xpc_dictionary_set_string(if_desc,
 +                                  vmnet_subnet_mask_key,
 +                                  options->subnet_mask);
 +    }
 +
 +#if defined(MAC_OS_VERSION_11_0) && \
 +    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
 +    xpc_dictionary_set_bool(
 +        if_desc,
 +        vmnet_enable_isolation_key,
 +        options->isolated
 +    );
 +#endif
 +
 +    return if_desc;
 +}
 +
 +static NetClientInfo net_vmnet_shared_info = {
 +    .type = NET_CLIENT_DRIVER_VMNET_SHARED,
 +    .size = sizeof(VmnetState),
 +    .receive = vmnet_receive_common,
 +    .cleanup = vmnet_cleanup_common,
 +};
 +
  int net_init_vmnet_shared(const Netdev *netdev, const char *name,
                            NetClientState *peer, Error **errp)
  {
 -  error_setg(errp, "vmnet-shared is not implemented yet");
 -  return -1;
 +    NetClientState *nc = qemu_new_net_client(&net_vmnet_shared_info,
 +                                             peer, "vmnet-shared", name);
 +    xpc_object_t if_desc;
 +    int result = -1;
 +
 +    if (!validate_options(netdev, errp)) {
 +        return result;
 +    }
 +
 +    if_desc = build_if_desc(netdev);
 +    result = vmnet_if_create(nc, if_desc, errp);
 +    xpc_release(if_desc);
 +    return result;
  }
 diff --git a/net/vmnet_int.h b/net/vmnet_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/net/vmnet_int.h
 +++ b/net/vmnet_int.h
@@ -XXX,XX +XXX,XX @@
  #include "clients.h"
  #include <vmnet/vmnet.h>
 +#include <dispatch/dispatch.h>
 +
 +/**
 + *  From vmnet.framework documentation
 + *
 + *  Each read/write call allows up to 200 packets to be
 + *  read or written for a maximum of 256KB.
 + *
 + *  Each packet written should be a complete
 + *  ethernet frame.
 + *
 + *  https://developer.apple.com/documentation/vmnet
 + */
 +#define VMNET_PACKETS_LIMIT 200
  typedef struct VmnetState {
 -  NetClientState nc;
 +    NetClientState nc;
 +    interface_ref vmnet_if;
 +
 +    uint64_t mtu;
 +    uint64_t max_packet_size;
 +    dispatch_queue_t if_queue;
 +
 +    QEMUBH *send_bh;
 +
 +    struct vmpktdesc packets_buf[VMNET_PACKETS_LIMIT];
 +    int packets_send_current_pos;
 +    int packets_send_end_pos;
 +
 +    struct iovec iov_buf[VMNET_PACKETS_LIMIT];
  } VmnetState;
 +const char *vmnet_status_map_str(vmnet_return_t status);
 +
 +int vmnet_if_create(NetClientState *nc,
 +                    xpc_object_t if_desc,
 +                    Error **errp);
 +
 +ssize_t vmnet_receive_common(NetClientState *nc,
 +                             const uint8_t *buf,
 +                             size_t size);
 +
 +void vmnet_cleanup_common(NetClientState *nc);
  #endif /* VMNET_INT_H */
 --
-.7.4
+.25.1

-New patch
+[PULL 4/8] net/vmnet: implement host mode (vmnet-host)
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ net/vmnet-host.c | 116 ++++++++++++++++++++++++++++++++++++++++++++---
+file changed, 110 insertions(+), 6 deletions(-)
+diff --git a/net/vmnet-host.c b/net/vmnet-host.c
+index XXXXXXX..XXXXXXX 100644
+--- a/net/vmnet-host.c
++++ b/net/vmnet-host.c
+@@ -XXX,XX +XXX,XX @@
+  */
+ #include "qemu/osdep.h"
++#include "qemu/uuid.h"
+ #include "qapi/qapi-types-net.h"
+-#include "vmnet_int.h"
+-#include "clients.h"
+-#include "qemu/error-report.h"
+ #include "qapi/error.h"
++#include "clients.h"
++#include "vmnet_int.h"
+ #include <vmnet/vmnet.h>
++
++static bool validate_options(const Netdev *netdev, Error **errp)
++{
++    const NetdevVmnetHostOptions *options = &(netdev->u.vmnet_host);
++
++#if defined(MAC_OS_VERSION_11_0) && \
++    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
++
++    QemuUUID net_uuid;
++    if (options->has_net_uuid &&
++        qemu_uuid_parse(options->net_uuid, &net_uuid) < 0) {
++        error_setg(errp, "Invalid UUID provided in 'net-uuid'");
++        return false;
++    }
++#else
++    if (options->has_isolated) {
++        error_setg(errp,
++                   "vmnet-host.isolated feature is "
++                   "unavailable: outdated vmnet.framework API");
++        return false;
++    }
++
++    if (options->has_net_uuid) {
++        error_setg(errp,
++                   "vmnet-host.net-uuid feature is "
++                   "unavailable: outdated vmnet.framework API");
++        return false;
++    }
++#endif
++
++    if ((options->has_start_address ||
++         options->has_end_address ||
++         options->has_subnet_mask) &&
++        !(options->has_start_address &&
++          options->has_end_address &&
++          options->has_subnet_mask)) {
++        error_setg(errp,
++                   "'start-address', 'end-address', 'subnet-mask' "
++                   "should be provided together");
++        return false;
++    }
++
++    return true;
++}
++
++static xpc_object_t build_if_desc(const Netdev *netdev)
++{
++    const NetdevVmnetHostOptions *options = &(netdev->u.vmnet_host);
++    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
++
++    xpc_dictionary_set_uint64(if_desc,
++                              vmnet_operation_mode_key,
++                              VMNET_HOST_MODE);
++
++#if defined(MAC_OS_VERSION_11_0) && \
++    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
++
++    xpc_dictionary_set_bool(if_desc,
++                            vmnet_enable_isolation_key,
++                            options->isolated);
++
++    QemuUUID net_uuid;
++    if (options->has_net_uuid) {
++        qemu_uuid_parse(options->net_uuid, &net_uuid);
++        xpc_dictionary_set_uuid(if_desc,
++                                vmnet_network_identifier_key,
++                                net_uuid.data);
++    }
++#endif
++
++    if (options->has_start_address) {
++        xpc_dictionary_set_string(if_desc,
++                                  vmnet_start_address_key,
++                                  options->start_address);
++        xpc_dictionary_set_string(if_desc,
++                                  vmnet_end_address_key,
++                                  options->end_address);
++        xpc_dictionary_set_string(if_desc,
++                                  vmnet_subnet_mask_key,
++                                  options->subnet_mask);
++    }
++
++    return if_desc;
++}
++
++static NetClientInfo net_vmnet_host_info = {
++    .type = NET_CLIENT_DRIVER_VMNET_HOST,
++    .size = sizeof(VmnetState),
++    .receive = vmnet_receive_common,
++    .cleanup = vmnet_cleanup_common,
++};
++
+ int net_init_vmnet_host(const Netdev *netdev, const char *name,
+-                        NetClientState *peer, Error **errp) {
+-  error_setg(errp, "vmnet-host is not implemented yet");
+-  return -1;
++                        NetClientState *peer, Error **errp)
++{
++    NetClientState *nc = qemu_new_net_client(&net_vmnet_host_info,
++                                             peer, "vmnet-host", name);
++    xpc_object_t if_desc;
++    int result = -1;
++
++    if (!validate_options(netdev, errp)) {
++        return result;
++    }
++
++    if_desc = build_if_desc(netdev);
++    result = vmnet_if_create(nc, if_desc, errp);
++    xpc_release(if_desc);
++    return result;
+ }
+--
+.25.1

-[Qemu-devel] [PULL 3/5] colo-compare: sort TCP packet queue by sequence number
+[PULL 5/8] net/vmnet: implement bridged mode (vmnet-bridged)
-From: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
-Improve efficiency of TCP packet comparison.
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-Signed-off-by: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
+Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
 Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- net/colo-compare.c | 19 +++++++++++++++++++
+ net/vmnet-bridged.m | 137 ++++++++++++++++++++++++++++++++++++++++++--
-file changed, 19 insertions(+)
+file changed, 132 insertions(+), 5 deletions(-)
-diff --git a/net/colo-compare.c b/net/colo-compare.c
+diff --git a/net/vmnet-bridged.m b/net/vmnet-bridged.m
 index XXXXXXX..XXXXXXX 100644
---- a/net/colo-compare.c
+--- a/net/vmnet-bridged.m
-+++ b/net/colo-compare.c
++++ b/net/vmnet-bridged.m
-@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CharBackend *out,
+@@ -XXX,XX +XXX,XX @@
-                             const uint8_t *buf,
-                             uint32_t size);
+ #include "qemu/osdep.h"
+ #include "qapi/qapi-types-net.h"
-+static gint seq_sorter(Packet *a, Packet *b, gpointer data)
+-#include "vmnet_int.h"
 -#include "clients.h"
 -#include "qemu/error-report.h"
  #include "qapi/error.h"
 +#include "clients.h"
 +#include "vmnet_int.h"
  #include <vmnet/vmnet.h>
 +
 +static bool validate_ifname(const char *ifname)
 +{
-+    struct tcphdr *atcp, *btcp;
++    xpc_object_t shared_if_list = vmnet_copy_shared_interface_list();
 +    bool match = false;
 +    if (!xpc_array_get_count(shared_if_list)) {
 +        goto done;
 +    }
 +
-+    atcp = (struct tcphdr *)(a->transport_header);
++    match = !xpc_array_apply(
-+    btcp = (struct tcphdr *)(b->transport_header);
++        shared_if_list,
-+    return ntohl(atcp->th_seq) - ntohl(btcp->th_seq);
++        ^bool(size_t index, xpc_object_t value) {
 +            return strcmp(xpc_string_get_string_ptr(value), ifname) != 0;
 +        });
 +
 +done:
 +    xpc_release(shared_if_list);
 +    return match;
 +}
 +
- /*
++
-  * Return 0 on success, if return -1 means the pkt
++static char* get_valid_ifnames()
-  * is unsupported(arp and ipv6) and will be sent later
++{
-@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode)
++    xpc_object_t shared_if_list = vmnet_copy_shared_interface_list();
-         if (g_queue_get_length(&conn->primary_list) <=
++    __block char *if_list = NULL;
-                                MAX_QUEUE_SIZE) {
++    __block char *if_list_prev = NULL;
-             g_queue_push_tail(&conn->primary_list, pkt);
++
-+            if (conn->ip_proto == IPPROTO_TCP) {
++    if (!xpc_array_get_count(shared_if_list)) {
-+                g_queue_sort(&conn->primary_list,
++        goto done;
-+                             (GCompareDataFunc)seq_sorter,
++    }
-+                             NULL);
++
-+            }
++    xpc_array_apply(
-         } else {
++        shared_if_list,
-             error_report("colo compare primary queue size too big,"
++        ^bool(size_t index, xpc_object_t value) {
-                          "drop packet");
++            /* build list of strings like "en0 en1 en2 " */
-@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode)
++            if_list = g_strconcat(xpc_string_get_string_ptr(value),
-         if (g_queue_get_length(&conn->secondary_list) <=
++                                  " ",
-                                MAX_QUEUE_SIZE) {
++                                  if_list_prev,
-             g_queue_push_tail(&conn->secondary_list, pkt);
++                                  NULL);
-+            if (conn->ip_proto == IPPROTO_TCP) {
++            g_free(if_list_prev);
-+                g_queue_sort(&conn->secondary_list,
++            if_list_prev = if_list;
-+                             (GCompareDataFunc)seq_sorter,
++            return true;
-+                             NULL);
++        });
-+            }
++
-         } else {
++done:
-             error_report("colo compare secondary queue size too big,"
++    xpc_release(shared_if_list);
-                          "drop packet");
++    return if_list;
 +}
 +
 +
 +static bool validate_options(const Netdev *netdev, Error **errp)
 +{
 +    const NetdevVmnetBridgedOptions *options = &(netdev->u.vmnet_bridged);
 +    char* if_list;
 +
 +    if (!validate_ifname(options->ifname)) {
 +        if_list = get_valid_ifnames();
 +        if (if_list) {
 +            error_setg(errp,
 +                       "unsupported ifname '%s', expected one of [ %s]",
 +                       options->ifname,
 +                       if_list);
 +            g_free(if_list);
 +        } else {
 +            error_setg(errp,
 +                       "unsupported ifname '%s', no supported "
 +                       "interfaces available",
 +                       options->ifname);
 +        }
 +        return false;
 +    }
 +
 +#if !defined(MAC_OS_VERSION_11_0) || \
 +    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_11_0
 +    if (options->has_isolated) {
 +        error_setg(errp,
 +                   "vmnet-bridged.isolated feature is "
 +                   "unavailable: outdated vmnet.framework API");
 +        return false;
 +    }
 +#endif
 +    return true;
 +}
 +
 +
 +static xpc_object_t build_if_desc(const Netdev *netdev)
 +{
 +    const NetdevVmnetBridgedOptions *options = &(netdev->u.vmnet_bridged);
 +    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
 +
 +    xpc_dictionary_set_uint64(if_desc,
 +                              vmnet_operation_mode_key,
 +                              VMNET_BRIDGED_MODE
 +    );
 +
 +    xpc_dictionary_set_string(if_desc,
 +                              vmnet_shared_interface_name_key,
 +                              options->ifname);
 +
 +#if defined(MAC_OS_VERSION_11_0) && \
 +    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
 +    xpc_dictionary_set_bool(if_desc,
 +                            vmnet_enable_isolation_key,
 +                            options->isolated);
 +#endif
 +    return if_desc;
 +}
 +
 +
 +static NetClientInfo net_vmnet_bridged_info = {
 +    .type = NET_CLIENT_DRIVER_VMNET_BRIDGED,
 +    .size = sizeof(VmnetState),
 +    .receive = vmnet_receive_common,
 +    .cleanup = vmnet_cleanup_common,
 +};
 +
 +
  int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
                             NetClientState *peer, Error **errp)
  {
 -  error_setg(errp, "vmnet-bridged is not implemented yet");
 -  return -1;
 +    NetClientState *nc = qemu_new_net_client(&net_vmnet_bridged_info,
 +                                             peer, "vmnet-bridged", name);
 +    xpc_object_t if_desc;
 +    int result = -1;
 +
 +    if (!validate_options(netdev, errp)) {
 +        return result;
 +    }
 +
 +    if_desc = build_if_desc(netdev);
 +    result = vmnet_if_create(nc, if_desc, errp);
 +    xpc_release(if_desc);
 +    return result;
  }
 --
-.7.4
+.25.1

-New patch
+[PULL 6/8] net/vmnet: update qemu-options.hx
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+Update qemu-options.hx to support vmnet networking backend.
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
+Signed-off-by: Jason Wang <jasowang@redhat.com>
+---
+ qemu-options.hx | 25 +++++++++++++++++++++++++
+file changed, 25 insertions(+)
+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,
+ #ifdef __linux__
+     "-netdev vhost-vdpa,id=str,vhostdev=/path/to/dev\n"
+     "                configure a vhost-vdpa network,Establish a vhost-vdpa netdev\n"
++#endif
++#ifdef CONFIG_VMNET
++    "-netdev vmnet-host,id=str[,isolated=on|off][,net-uuid=uuid]\n"
++    "         [,start-address=addr,end-address=addr,subnet-mask=mask]\n"
++    "                configure a vmnet network backend in host mode with ID 'str',\n"
++    "                isolate this interface from others with 'isolated',\n"
++    "                configure the address range and choose a subnet mask,\n"
++    "                specify network UUID 'uuid' to disable DHCP and interact with\n"
++    "                vmnet-host interfaces within this isolated network\n"
++    "-netdev vmnet-shared,id=str[,isolated=on|off][,nat66-prefix=addr]\n"
++    "         [,start-address=addr,end-address=addr,subnet-mask=mask]\n"
++    "                configure a vmnet network backend in shared mode with ID 'str',\n"
++    "                configure the address range and choose a subnet mask,\n"
++    "                set IPv6 ULA prefix (of length 64) to use for internal network,\n"
++    "                isolate this interface from others with 'isolated'\n"
++    "-netdev vmnet-bridged,id=str,ifname=name[,isolated=on|off]\n"
++    "                configure a vmnet network backend in bridged mode with ID 'str',\n"
++    "                use 'ifname=name' to select a physical network interface to be bridged,\n"
++    "                isolate this interface from others with 'isolated'\n"
+ #endif
+     "-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
+     "                configure a hub port on the hub with ID 'n'\n", QEMU_ARCH_ALL)
+@@ -XXX,XX +XXX,XX @@ DEF("nic", HAS_ARG, QEMU_OPTION_nic,
+ #endif
+ #ifdef CONFIG_POSIX
+     "vhost-user|"
++#endif
++#ifdef CONFIG_VMNET
++    "vmnet-host|vmnet-shared|vmnet-bridged|"
+ #endif
+     "socket][,option][,...][mac=macaddr]\n"
+     "                initialize an on-board / default host NIC (using MAC address\n"
+@@ -XXX,XX +XXX,XX @@ DEF("net", HAS_ARG, QEMU_OPTION_net,
+ #endif
+ #ifdef CONFIG_NETMAP
+     "netmap|"
++#endif
++#ifdef CONFIG_VMNET
++    "vmnet-host|vmnet-shared|vmnet-bridged|"
+ #endif
+     "socket][,option][,option][,...]\n"
+     "                old way to initialize a host network interface\n"
+--
+.25.1

-[Qemu-devel] [PULL 4/5] net: imx: limit buffer descriptor count
+[PULL 7/8] net/vmnet: update hmp-commands.hx
-From: Prasad J Pandit <pjp@fedoraproject.org>
+From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
-i.MX Fast Ethernet Controller uses buffer descriptors to manage
+Update HMP for supporting vmnet.
 data flow to/fro receive & transmit queues. While transmitting
 packets, it could continue to read buffer descriptors if a buffer
 descriptor has length of zero and has crafted values in bd.flags.
 Set an upper limit to number of buffer descriptors.
-Reported-by: Li Qiang <liqiang6-s@360.cn>
+Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-Signed-off-by: Prasad J Pandit <pjp@fedoraproject.org>
+Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/imx_fec.c | 10 ++++++----
+ hmp-commands.hx | 6 +++++-
-file changed, 6 insertions(+), 4 deletions(-)
+file changed, 5 insertions(+), 1 deletion(-)
-diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
+diff --git a/hmp-commands.hx b/hmp-commands.hx
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/imx_fec.c
+--- a/hmp-commands.hx
-+++ b/hw/net/imx_fec.c
++++ b/hmp-commands.hx
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ ERST
-         } \
+     {
-     } while (0)
+         .name       = "netdev_add",
+         .args_type  = "netdev:O",
-+#define IMX_MAX_DESC    1024
+-        .params     = "[user|tap|socket|vde|bridge|hubport|netmap|vhost-user],id=str[,prop=value][,...]",
-+
++        .params     = "[user|tap|socket|vde|bridge|hubport|netmap|vhost-user"
- static const char *imx_default_reg_name(IMXFECState *s, uint32_t index)
++#ifdef CONFIG_VMNET
- {
++                      "|vmnet-host|vmnet-shared|vmnet-bridged"
-     static char tmp[20];
++#endif
-@@ -XXX,XX +XXX,XX @@ static void imx_eth_update(IMXFECState *s)
++                      "],id=str[,prop=value][,...]",
+         .help       = "add host network device",
- static void imx_fec_do_tx(IMXFECState *s)
+         .cmd        = hmp_netdev_add,
- {
+         .command_completion = netdev_add_completion,
 -    int frame_size = 0;
 +    int frame_size = 0, descnt = 0;
      uint8_t frame[ENET_MAX_FRAME_SIZE];
      uint8_t *ptr = frame;
      uint32_t addr = s->tx_descriptor;
 -    while (1) {
 +    while (descnt++ < IMX_MAX_DESC) {
          IMXFECBufDesc bd;
          int len;
@@ -XXX,XX +XXX,XX @@ static void imx_fec_do_tx(IMXFECState *s)
  static void imx_enet_do_tx(IMXFECState *s)
  {
 -    int frame_size = 0;
 +    int frame_size = 0, descnt = 0;
      uint8_t frame[ENET_MAX_FRAME_SIZE];
      uint8_t *ptr = frame;
      uint32_t addr = s->tx_descriptor;
 -    while (1) {
 +    while (descnt++ < IMX_MAX_DESC) {
          IMXENETBufDesc bd;
          int len;
 --
-.7.4
+.25.1

-[Qemu-devel] [PULL 2/5] net: e1000e: fix dead code in e1000e_write_packet_to_guest
+[PULL 8/8] tulip: Assign default MAC address if not specified
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Helge Deller <deller@gmx.de>
-Because is_first is declared inside a loop, it is always true.  The store
+The MAC of the tulip card is stored in the EEPROM and at startup
-is dead, and so is the "else" branch of "if (is_first)".  is_last is
+tulip_fill_eeprom() is called to initialize the EEPROM with the MAC
-okay though.
+address given on the command line, e.g.:
     -device tulip,mac=00:11:22:33:44:55
-Reported by Coverity.
+In case the mac address was not given on the command line,
 tulip_fill_eeprom() initializes the MAC in EEPROM with 00:00:00:00:00:00
 which breaks e.g. a HP-UX guest.
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Fix this problem by moving qemu_macaddr_default_if_unset() a few lines
-Reviewed-by: Dmitry Fleytman <dmitry@daynix.com>
+up, so that a default mac address is assigned before tulip_fill_eeprom()
 initializes the EEPROM.
 Signed-off-by: Helge Deller <deller@gmx.de>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Jason Wang <jasowang@redhat.com>
 ---
- hw/net/e1000e_core.c | 2 +-
+ hw/net/tulip.c | 4 ++--
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
+diff --git a/hw/net/tulip.c b/hw/net/tulip.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/net/e1000e_core.c
+--- a/hw/net/tulip.c
-+++ b/hw/net/e1000e_core.c
++++ b/hw/net/tulip.c
-@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
+@@ -XXX,XX +XXX,XX @@ static void pci_tulip_realize(PCIDevice *pci_dev, Error **errp)
-     const E1000E_RingInfo *rxi;
+     pci_conf = s->dev.config;
-     size_t ps_hdr_len = 0;
+     pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */
-     bool do_ps = e1000e_do_ps(core, pkt, &ps_hdr_len);
-+    bool is_first = true;
++    qemu_macaddr_default_if_unset(&s->c.macaddr);
++
-     rxi = rxr->i;
+     s->eeprom = eeprom93xx_new(&pci_dev->qdev, 64);
+     tulip_fill_eeprom(s);
-@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
-         hwaddr ba[MAX_PS_BUFFERS];
+@@ -XXX,XX +XXX,XX @@ static void pci_tulip_realize(PCIDevice *pci_dev, Error **errp)
-         e1000e_ba_state bastate = { { 0 } };
-         bool is_last = false;
+     s->irq = pci_allocate_irq(&s->dev);
--        bool is_first = true;
+-    qemu_macaddr_default_if_unset(&s->c.macaddr);
-         desc_size = total_size - desc_offset;
+-
+     s->nic = qemu_new_nic(&net_tulip_info, &s->c,
                            object_get_typename(OBJECT(pci_dev)),
                            pci_dev->qdev.id, s);
 --
-.7.4
+.25.1

The following changes since commit 5dae13cd71f0755a1395b5a4cde635b8a6ee3f58:

Merge remote-tracking branch 'remotes/rth/tags/pull-or-20170214' into staging (2017-02-14 09:55:48 +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 4154c7e03fa55b4cf52509a83d50d6c09d743b77:

net: e1000e: fix an infinite loop issue (2017-02-15 11:18:57 +0800)

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

----------------------------------------------------------------
Li Qiang (1):
      net: e1000e: fix an infinite loop issue

Paolo Bonzini (1):
      net: e1000e: fix dead code in e1000e_write_packet_to_guest

Prasad J Pandit (1):
      net: imx: limit buffer descriptor count

Thomas Huth (1):
      net: Mark 'vlan' parameter as deprecated

Zhang Chen (1):
      colo-compare: sort TCP packet queue by sequence number

hw/net/e1000e_core.c |  9 +++++++--
 hw/net/imx_fec.c     | 10 ++++++----
 net/colo-compare.c   | 19 +++++++++++++++++++
 net/net.c            |  6 ++++++
 4 files changed, 38 insertions(+), 6 deletions(-)

From: Thomas Huth <thuth@redhat.com>

The 'vlan' parameter is a continuous source of confusion for the users,
many people mix it up with the more common term VLAN (the link layer
packet encapsulation), and even if they realize that the QEMU 'vlan' is
rather some kind of network hub emulation, there is still a high risk
that they configure their QEMU networking in a wrong way with this
parameter (e.g. by hooking NICs together, so they get a 'loopback'
between one and the other NIC).
Thus at one point in time, we should finally get rid of the 'vlan'
feature in QEMU. Let's do a first step in this direction by declaring
the 'vlan' parameter as deprecated and informing the users to use the
'netdev' parameter instead.

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

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)
     const Netdev *netdev;
     const char *name;
     NetClientState *peer = NULL;
+    static bool vlan_warned;
 
     if (is_netdev) {
         netdev = object;
@@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp)
             !opts->u.nic.data->has_netdev) {
             peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL);
         }
+
+        if (net->has_vlan && !vlan_warned) {
+            error_report("'vlan' is deprecated. Please use 'netdev' instead.");
+            vlan_warned = true;
+        }
     }
 
     if (net_client_init_fun[netdev->type](netdev, name, peer, errp) < 0) {
-- 
2.7.4

From: Paolo Bonzini <pbonzini@redhat.com>

Because is_first is declared inside a loop, it is always true.  The store
is dead, and so is the "else" branch of "if (is_first)".  is_last is
okay though.

Reported by Coverity.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Dmitry Fleytman <dmitry@daynix.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000e_core.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000e_core.c
+++ b/hw/net/e1000e_core.c
@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
     const E1000E_RingInfo *rxi;
     size_t ps_hdr_len = 0;
     bool do_ps = e1000e_do_ps(core, pkt, &ps_hdr_len);
+    bool is_first = true;
 
     rxi = rxr->i;
 
@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
         hwaddr ba[MAX_PS_BUFFERS];
         e1000e_ba_state bastate = { { 0 } };
         bool is_last = false;
-        bool is_first = true;
 
         desc_size = total_size - desc_offset;
 
-- 
2.7.4

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

Improve efficiency of TCP packet comparison.

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

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 compare_chr_send(CharBackend *out,
                             const uint8_t *buf,
                             uint32_t size);
 
+static gint seq_sorter(Packet *a, Packet *b, gpointer data)
+{
+    struct tcphdr *atcp, *btcp;
+
+    atcp = (struct tcphdr *)(a->transport_header);
+    btcp = (struct tcphdr *)(b->transport_header);
+    return ntohl(atcp->th_seq) - ntohl(btcp->th_seq);
+}
+
 /*
  * Return 0 on success, if return -1 means the pkt
  * is unsupported(arp and ipv6) and will be sent later
@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode)
         if (g_queue_get_length(&conn->primary_list) <=
                                MAX_QUEUE_SIZE) {
             g_queue_push_tail(&conn->primary_list, pkt);
+            if (conn->ip_proto == IPPROTO_TCP) {
+                g_queue_sort(&conn->primary_list,
+                             (GCompareDataFunc)seq_sorter,
+                             NULL);
+            }
         } else {
             error_report("colo compare primary queue size too big,"
                          "drop packet");
@@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode)
         if (g_queue_get_length(&conn->secondary_list) <=
                                MAX_QUEUE_SIZE) {
             g_queue_push_tail(&conn->secondary_list, pkt);
+            if (conn->ip_proto == IPPROTO_TCP) {
+                g_queue_sort(&conn->secondary_list,
+                             (GCompareDataFunc)seq_sorter,
+                             NULL);
+            }
         } else {
             error_report("colo compare secondary queue size too big,"
                          "drop packet");
-- 
2.7.4

From: Prasad J Pandit <pjp@fedoraproject.org>

i.MX Fast Ethernet Controller uses buffer descriptors to manage
data flow to/fro receive & transmit queues. While transmitting
packets, it could continue to read buffer descriptors if a buffer
descriptor has length of zero and has crafted values in bd.flags.
Set an upper limit to number of buffer descriptors.

Reported-by: Li Qiang <liqiang6-s@360.cn>
Signed-off-by: Prasad J Pandit <pjp@fedoraproject.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/imx_fec.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/imx_fec.c
+++ b/hw/net/imx_fec.c
@@ -XXX,XX +XXX,XX @@
         } \
     } while (0)
 
+#define IMX_MAX_DESC    1024
+
 static const char *imx_default_reg_name(IMXFECState *s, uint32_t index)
 {
     static char tmp[20];
@@ -XXX,XX +XXX,XX @@ static void imx_eth_update(IMXFECState *s)
 
 static void imx_fec_do_tx(IMXFECState *s)
 {
-    int frame_size = 0;
+    int frame_size = 0, descnt = 0;
     uint8_t frame[ENET_MAX_FRAME_SIZE];
     uint8_t *ptr = frame;
     uint32_t addr = s->tx_descriptor;
 
-    while (1) {
+    while (descnt++ < IMX_MAX_DESC) {
         IMXFECBufDesc bd;
         int len;
 
@@ -XXX,XX +XXX,XX @@ static void imx_fec_do_tx(IMXFECState *s)
 
 static void imx_enet_do_tx(IMXFECState *s)
 {
-    int frame_size = 0;
+    int frame_size = 0, descnt = 0;
     uint8_t frame[ENET_MAX_FRAME_SIZE];
     uint8_t *ptr = frame;
     uint32_t addr = s->tx_descriptor;
 
-    while (1) {
+    while (descnt++ < IMX_MAX_DESC) {
         IMXENETBufDesc bd;
         int len;
 
-- 
2.7.4

From: Li Qiang <liq3ea@gmail.com>

This issue is like the issue in e1000 network card addressed in
this commit:
e1000: eliminate infinite loops on out-of-bounds transfer start.

Signed-off-by: Li Qiang <liqiang6-s@360.cn>
Reviewed-by: Dmitry Fleytman <dmitry@daynix.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/e1000e_core.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/e1000e_core.c
+++ b/hw/net/e1000e_core.c
@@ -XXX,XX +XXX,XX @@ typedef struct E1000E_RingInfo_st {
 static inline bool
 e1000e_ring_empty(E1000ECore *core, const E1000E_RingInfo *r)
 {
-    return core->mac[r->dh] == core->mac[r->dt];
+    return core->mac[r->dh] == core->mac[r->dt] ||
+                core->mac[r->dt] >= core->mac[r->dlen] / E1000_RING_DESC_LEN;
 }
 
 static inline uint64_t
@@ -XXX,XX +XXX,XX @@ e1000e_write_packet_to_guest(E1000ECore *core, struct NetRxPkt *pkt,
             desc_size = core->rx_desc_buf_size;
         }
 
+        if (e1000e_ring_empty(core, rxi)) {
+            return;
+        }
+
         base = e1000e_ring_head_descr(core, rxi);
 
         pci_dma_read(d, base, &desc, core->rx_desc_len);
-- 
2.7.4

The following changes since commit eec398119fc6911d99412c37af06a6bc27871f85:

Merge tag 'for_upstream' of git://git.kernel.org/pub/scm/virt/kvm/mst/qemu into staging (2022-05-16 16:31:01 -0700)

are available in the git repository at:

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

for you to fetch changes up to 052c2579b89b0d87debe8b05594b5180f0fde87d:

tulip: Assign default MAC address if not specified (2022-05-17 16:48:23 +0800)

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

----------------------------------------------------------------
Helge Deller (1):
      tulip: Assign default MAC address if not specified

Vladislav Yaroshchuk (7):
      net/vmnet: add vmnet dependency and customizable option
      net/vmnet: add vmnet backends to qapi/net
      net/vmnet: implement shared mode (vmnet-shared)
      net/vmnet: implement host mode (vmnet-host)
      net/vmnet: implement bridged mode (vmnet-bridged)
      net/vmnet: update qemu-options.hx
      net/vmnet: update hmp-commands.hx

hmp-commands.hx               |   6 +-
 hw/net/tulip.c                |   4 +-
 meson.build                   |  16 +-
 meson_options.txt             |   2 +
 net/clients.h                 |  11 ++
 net/meson.build               |   7 +
 net/net.c                     |  10 ++
 net/vmnet-bridged.m           | 152 +++++++++++++++++
 net/vmnet-common.m            | 378 ++++++++++++++++++++++++++++++++++++++++++
 net/vmnet-host.c              | 128 ++++++++++++++
 net/vmnet-shared.c            | 114 +++++++++++++
 net/vmnet_int.h               |  63 +++++++
 qapi/net.json                 | 133 ++++++++++++++-
 qemu-options.hx               |  25 +++
 scripts/meson-buildoptions.sh |   1 +
 15 files changed, 1044 insertions(+), 6 deletions(-)
 create mode 100644 net/vmnet-bridged.m
 create mode 100644 net/vmnet-common.m
 create mode 100644 net/vmnet-host.c
 create mode 100644 net/vmnet-shared.c
 create mode 100644 net/vmnet_int.h

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

vmnet.framework dependency is added with 'vmnet' option
to enable or disable it. Default value is 'auto'.

used vmnet features are available since macOS 11.0,
but new backend can be built and work properly with
subset of them on 10.15 too.

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 meson.build                   | 16 +++++++++++++++-
 meson_options.txt             |  2 ++
 scripts/meson-buildoptions.sh |  1 +
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ if cocoa.found() and get_option('gtk').enabled()
   error('Cocoa and GTK+ cannot be enabled at the same time')
 endif
 
+vmnet = dependency('appleframeworks', modules: 'vmnet', required: get_option('vmnet'))
+if vmnet.found() and not cc.has_header_symbol('vmnet/vmnet.h',
+                                              'VMNET_BRIDGED_MODE',
+                                              dependencies: vmnet)
+  vmnet = not_found
+  if get_option('vmnet').enabled()
+    error('vmnet.framework API is outdated')
+  else
+    warning('vmnet.framework API is outdated, disabling')
+  endif
+endif
+
 seccomp = not_found
 if not get_option('seccomp').auto() or have_system or have_tools
   seccomp = dependency('libseccomp', version: '>=2.3.0',
@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_VHOST_KERNEL', have_vhost_kernel)
 config_host_data.set('CONFIG_VHOST_USER', have_vhost_user)
 config_host_data.set('CONFIG_VHOST_CRYPTO', have_vhost_user_crypto)
 config_host_data.set('CONFIG_VHOST_VDPA', have_vhost_vdpa)
+config_host_data.set('CONFIG_VMNET', vmnet.found())
 config_host_data.set('CONFIG_VHOST_USER_BLK_SERVER', have_vhost_user_blk_server)
 config_host_data.set('CONFIG_PNG', png.found())
 config_host_data.set('CONFIG_VNC', vnc.found())
@@ -XXX,XX +XXX,XX @@ summary(summary_info, bool_yn: true, section: 'Crypto')
 # Libraries
 summary_info = {}
 if targetos == 'darwin'
-  summary_info += {'Cocoa support':   cocoa}
+  summary_info += {'Cocoa support':           cocoa}
+  summary_info += {'vmnet.framework support': vmnet}
 endif
 summary_info += {'SDL support':       sdl}
 summary_info += {'SDL image support': sdl_image}
diff --git a/meson_options.txt b/meson_options.txt
index XXXXXXX..XXXXXXX 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -XXX,XX +XXX,XX @@ option('netmap', type : 'feature', value : 'auto',
        description: 'netmap network backend support')
 option('vde', type : 'feature', value : 'auto',
        description: 'vde network backend support')
+option('vmnet', type : 'feature', value : 'auto',
+       description: 'vmnet.framework network backend support')
 option('virglrenderer', type : 'feature', value : 'auto',
        description: 'virgl rendering support')
 option('png', type : 'feature', value : 'auto',
diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
index XXXXXXX..XXXXXXX 100644
--- a/scripts/meson-buildoptions.sh
+++ b/scripts/meson-buildoptions.sh
@@ -XXX,XX +XXX,XX @@ meson_options_help() {
   printf "%s\n" '  vhost-kernel    vhost kernel backend support'
   printf "%s\n" '  vhost-net       vhost-net kernel acceleration support'
   printf "%s\n" '  vhost-user      vhost-user backend support'
+  printf "%s\n" '  vmnet           vmnet.framework network backend support'
   printf "%s\n" '  vhost-user-blk-server'
   printf "%s\n" '                  build vhost-user-blk server'
   printf "%s\n" '  vhost-vdpa      vhost-vdpa kernel backend support'
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Create separate netdevs for each vmnet operating mode:
- vmnet-host
- vmnet-shared
- vmnet-bridged

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/clients.h       |  11 ++++
 net/meson.build     |   7 +++
 net/net.c           |  10 ++++
 net/vmnet-bridged.m |  25 +++++++++
 net/vmnet-common.m  |  19 +++++++
 net/vmnet-host.c    |  24 ++++++++
 net/vmnet-shared.c  |  25 +++++++++
 net/vmnet_int.h     |  25 +++++++++
 qapi/net.json       | 133 +++++++++++++++++++++++++++++++++++++++++++-
 9 files changed, 277 insertions(+), 2 deletions(-)
 create mode 100644 net/vmnet-bridged.m
 create mode 100644 net/vmnet-common.m
 create mode 100644 net/vmnet-host.c
 create mode 100644 net/vmnet-shared.c
 create mode 100644 net/vmnet_int.h

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_vhost_user(const Netdev *netdev, const char *name,
 
 int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
                         NetClientState *peer, Error **errp);
+#ifdef CONFIG_VMNET
+int net_init_vmnet_host(const Netdev *netdev, const char *name,
+                          NetClientState *peer, Error **errp);
+
+int net_init_vmnet_shared(const Netdev *netdev, const char *name,
+                          NetClientState *peer, Error **errp);
+
+int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
+                          NetClientState *peer, Error **errp);
+#endif /* CONFIG_VMNET */
+
 #endif /* QEMU_NET_CLIENTS_H */
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 @@ if have_vhost_net_vdpa
   softmmu_ss.add(files('vhost-vdpa.c'))
 endif
 
+vmnet_files = files(
+  'vmnet-common.m',
+  'vmnet-bridged.m',
+  'vmnet-host.c',
+  'vmnet-shared.c'
+)
+softmmu_ss.add(when: vmnet, if_true: vmnet_files)
 subdir('can')
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 (* const net_client_init_fun[NET_CLIENT_DRIVER__MAX])(
 #ifdef CONFIG_L2TPV3
         [NET_CLIENT_DRIVER_L2TPV3]    = net_init_l2tpv3,
 #endif
+#ifdef CONFIG_VMNET
+        [NET_CLIENT_DRIVER_VMNET_HOST] = net_init_vmnet_host,
+        [NET_CLIENT_DRIVER_VMNET_SHARED] = net_init_vmnet_shared,
+        [NET_CLIENT_DRIVER_VMNET_BRIDGED] = net_init_vmnet_bridged,
+#endif /* CONFIG_VMNET */
 };
 
 
@@ -XXX,XX +XXX,XX @@ void show_netdevs(void)
 #endif
 #ifdef CONFIG_VHOST_VDPA
         "vhost-vdpa",
+#endif
+#ifdef CONFIG_VMNET
+        "vmnet-host",
+        "vmnet-shared",
+        "vmnet-bridged",
 #endif
     };
 
diff --git a/net/vmnet-bridged.m b/net/vmnet-bridged.m
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/vmnet-bridged.m
@@ -XXX,XX +XXX,XX @@
+/*
+ * vmnet-bridged.m
+ *
+ * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/qapi-types-net.h"
+#include "vmnet_int.h"
+#include "clients.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+
+#include <vmnet/vmnet.h>
+
+int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
+                           NetClientState *peer, Error **errp)
+{
+  error_setg(errp, "vmnet-bridged is not implemented yet");
+  return -1;
+}
diff --git a/net/vmnet-common.m b/net/vmnet-common.m
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/vmnet-common.m
@@ -XXX,XX +XXX,XX @@
+/*
+ * vmnet-common.m - network client wrapper for Apple vmnet.framework
+ *
+ * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+ * Copyright(c) 2021 Phillip Tennen <phillip@axleos.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/qapi-types-net.h"
+#include "vmnet_int.h"
+#include "clients.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+
+#include <vmnet/vmnet.h>
diff --git a/net/vmnet-host.c b/net/vmnet-host.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/vmnet-host.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * vmnet-host.c
+ *
+ * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/qapi-types-net.h"
+#include "vmnet_int.h"
+#include "clients.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+
+#include <vmnet/vmnet.h>
+
+int net_init_vmnet_host(const Netdev *netdev, const char *name,
+                        NetClientState *peer, Error **errp) {
+  error_setg(errp, "vmnet-host is not implemented yet");
+  return -1;
+}
diff --git a/net/vmnet-shared.c b/net/vmnet-shared.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/vmnet-shared.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * vmnet-shared.c
+ *
+ * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/qapi-types-net.h"
+#include "vmnet_int.h"
+#include "clients.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+
+#include <vmnet/vmnet.h>
+
+int net_init_vmnet_shared(const Netdev *netdev, const char *name,
+                          NetClientState *peer, Error **errp)
+{
+  error_setg(errp, "vmnet-shared is not implemented yet");
+  return -1;
+}
diff --git a/net/vmnet_int.h b/net/vmnet_int.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/net/vmnet_int.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * vmnet_int.h
+ *
+ * Copyright(c) 2022 Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+#ifndef VMNET_INT_H
+#define VMNET_INT_H
+
+#include "qemu/osdep.h"
+#include "vmnet_int.h"
+#include "clients.h"
+
+#include <vmnet/vmnet.h>
+
+typedef struct VmnetState {
+  NetClientState nc;
+
+} VmnetState;
+
+
+#endif /* VMNET_INT_H */
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':     'str',
     '*queues':       'int' } }
 
+##
+# @NetdevVmnetHostOptions:
+#
+# vmnet (host mode) network backend.
+#
+# Allows the vmnet interface to communicate with other vmnet
+# interfaces that are in host mode and also with the host.
+#
+# @start-address: The starting IPv4 address to use for the interface.
+#                 Must be in the private IP range (RFC 1918). Must be
+#                 specified along with @end-address and @subnet-mask.
+#                 This address is used as the gateway address. The
+#                 subsequent address up to and including end-address are
+#                 placed in the DHCP pool.
+#
+# @end-address: The DHCP IPv4 range end address to use for the
+#               interface. Must be in the private IP range (RFC 1918).
+#               Must be specified along with @start-address and
+#               @subnet-mask.
+#
+# @subnet-mask: The IPv4 subnet mask to use on the interface. Must
+#               be specified along with @start-address and @subnet-mask.
+#
+# @isolated: Enable isolation for this interface. Interface isolation
+#            ensures that vmnet interface is not able to communicate
+#            with any other vmnet interfaces. Only communication with
+#            host is allowed. Requires at least macOS Big Sur 11.0.
+#
+# @net-uuid: The identifier (UUID) to uniquely identify the isolated
+#            network vmnet interface should be added to. If
+#            set, no DHCP service is provided for this interface and
+#            network communication is allowed only with other interfaces
+#            added to this network identified by the UUID. Requires
+#            at least macOS Big Sur 11.0.
+#
+# Since: 7.1
+##
+{ 'struct': 'NetdevVmnetHostOptions',
+  'data': {
+    '*start-address': 'str',
+    '*end-address':   'str',
+    '*subnet-mask':   'str',
+    '*isolated':      'bool',
+    '*net-uuid':      'str' },
+  'if': 'CONFIG_VMNET' }
+
+##
+# @NetdevVmnetSharedOptions:
+#
+# vmnet (shared mode) network backend.
+#
+# Allows traffic originating from the vmnet interface to reach the
+# Internet through a network address translator (NAT).
+# The vmnet interface can communicate with the host and with
+# other shared mode interfaces on the same subnet. If no DHCP
+# settings, subnet mask and IPv6 prefix specified, the interface can
+# communicate with any of other interfaces in shared mode.
+#
+# @start-address: The starting IPv4 address to use for the interface.
+#                 Must be in the private IP range (RFC 1918). Must be
+#                 specified along with @end-address and @subnet-mask.
+#                 This address is used as the gateway address. The
+#                 subsequent address up to and including end-address are
+#                 placed in the DHCP pool.
+#
+# @end-address: The DHCP IPv4 range end address to use for the
+#               interface. Must be in the private IP range (RFC 1918).
+#               Must be specified along with @start-address and @subnet-mask.
+#
+# @subnet-mask: The IPv4 subnet mask to use on the interface. Must
+#                be specified along with @start-address and @subnet-mask.
+#
+# @isolated: Enable isolation for this interface. Interface isolation
+#            ensures that vmnet interface is not able to communicate
+#            with any other vmnet interfaces. Only communication with
+#            host is allowed. Requires at least macOS Big Sur 11.0.
+#
+# @nat66-prefix: The IPv6 prefix to use into guest network. Must be a
+#                unique local address i.e. start with fd00::/8 and have
+#                length of 64.
+#
+# Since: 7.1
+##
+{ 'struct': 'NetdevVmnetSharedOptions',
+  'data': {
+    '*start-address': 'str',
+    '*end-address':   'str',
+    '*subnet-mask':   'str',
+    '*isolated':      'bool',
+    '*nat66-prefix':  'str' },
+  'if': 'CONFIG_VMNET' }
+
+##
+# @NetdevVmnetBridgedOptions:
+#
+# vmnet (bridged mode) network backend.
+#
+# Bridges the vmnet interface with a physical network interface.
+#
+# @ifname: The name of the physical interface to be bridged.
+#
+# @isolated: Enable isolation for this interface. Interface isolation
+#            ensures that vmnet interface is not able to communicate
+#            with any other vmnet interfaces. Only communication with
+#            host is allowed. Requires at least macOS Big Sur 11.0.
+#
+# Since: 7.1
+##
+{ 'struct': 'NetdevVmnetBridgedOptions',
+  'data': {
+    'ifname':     'str',
+    '*isolated':  'bool' },
+  'if': 'CONFIG_VMNET' }
+
 ##
 # @NetClientDriver:
 #
@@ -XXX,XX +XXX,XX @@
 # Since: 2.7
 #
 #        @vhost-vdpa since 5.1
+#        @vmnet-host since 7.1
+#        @vmnet-shared since 7.1
+#        @vmnet-bridged since 7.1
 ##
 { 'enum': 'NetClientDriver',
   'data': [ 'none', 'nic', 'user', 'tap', 'l2tpv3', 'socket', 'vde',
-            'bridge', 'hubport', 'netmap', 'vhost-user', 'vhost-vdpa' ] }
+            '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' }] }
 
 ##
 # @Netdev:
@@ -XXX,XX +XXX,XX @@
 # Since: 1.2
 #
 #        'l2tpv3' - since 2.1
+#        'vmnet-host' - since 7.1
+#        'vmnet-shared' - since 7.1
+#        'vmnet-bridged' - since 7.1
 ##
 { 'union': 'Netdev',
   'base': { 'id': 'str', 'type': 'NetClientDriver' },
@@ -XXX,XX +XXX,XX @@
     'hubport':  'NetdevHubPortOptions',
     'netmap':   'NetdevNetmapOptions',
     'vhost-user': 'NetdevVhostUserOptions',
-    'vhost-vdpa': 'NetdevVhostVDPAOptions' } }
+    'vhost-vdpa': 'NetdevVhostVDPAOptions',
+    'vmnet-host': { 'type': 'NetdevVmnetHostOptions',
+                    'if': 'CONFIG_VMNET' },
+    'vmnet-shared': { 'type': 'NetdevVmnetSharedOptions',
+                      'if': 'CONFIG_VMNET' },
+    'vmnet-bridged': { 'type': 'NetdevVmnetBridgedOptions',
+                       'if': 'CONFIG_VMNET' } } }
 
 ##
 # @RxState:
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Interaction with vmnet.framework in different modes
differs only on configuration stage, so we can create
common `send`, `receive`, etc. procedures and reuse them.

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Phillip Tennen <phillip@axleos.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/vmnet-common.m | 359 +++++++++++++++++++++++++++++++++++++++++++++
 net/vmnet-shared.c |  97 +++++++++++-
 net/vmnet_int.h    |  40 ++++-
 3 files changed, 491 insertions(+), 5 deletions(-)

diff --git a/net/vmnet-common.m b/net/vmnet-common.m
index XXXXXXX..XXXXXXX 100644
--- a/net/vmnet-common.m
+++ b/net/vmnet-common.m
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "qemu/main-loop.h"
+#include "qemu/log.h"
 #include "qapi/qapi-types-net.h"
 #include "vmnet_int.h"
 #include "clients.h"
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 
 #include <vmnet/vmnet.h>
+#include <dispatch/dispatch.h>
+
+
+static void vmnet_send_completed(NetClientState *nc, ssize_t len);
+
+
+const char *vmnet_status_map_str(vmnet_return_t status)
+{
+    switch (status) {
+    case VMNET_SUCCESS:
+        return "success";
+    case VMNET_FAILURE:
+        return "general failure (possibly not enough privileges)";
+    case VMNET_MEM_FAILURE:
+        return "memory allocation failure";
+    case VMNET_INVALID_ARGUMENT:
+        return "invalid argument specified";
+    case VMNET_SETUP_INCOMPLETE:
+        return "interface setup is not complete";
+    case VMNET_INVALID_ACCESS:
+        return "invalid access, permission denied";
+    case VMNET_PACKET_TOO_BIG:
+        return "packet size is larger than MTU";
+    case VMNET_BUFFER_EXHAUSTED:
+        return "buffers exhausted in kernel";
+    case VMNET_TOO_MANY_PACKETS:
+        return "packet count exceeds limit";
+#if defined(MAC_OS_VERSION_11_0) && \
+    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
+    case VMNET_SHARING_SERVICE_BUSY:
+        return "conflict, sharing service is in use";
+#endif
+    default:
+        return "unknown vmnet error";
+    }
+}
+
+
+/**
+ * Write packets from QEMU to vmnet interface.
+ *
+ * vmnet.framework supports iov, but writing more than
+ * one iov into vmnet interface fails with
+ * 'VMNET_INVALID_ARGUMENT'. Collecting provided iovs into
+ * one and passing it to vmnet works fine. That's the
+ * reason why receive_iov() left unimplemented. But it still
+ * works with good performance having .receive() only.
+ */
+ssize_t vmnet_receive_common(NetClientState *nc,
+                             const uint8_t *buf,
+                             size_t size)
+{
+    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
+    struct vmpktdesc packet;
+    struct iovec iov;
+    int pkt_cnt;
+    vmnet_return_t if_status;
+
+    if (size > s->max_packet_size) {
+        warn_report("vmnet: packet is too big, %zu > %" PRIu64,
+            packet.vm_pkt_size,
+            s->max_packet_size);
+        return -1;
+    }
+
+    iov.iov_base = (char *) buf;
+    iov.iov_len = size;
+
+    packet.vm_pkt_iovcnt = 1;
+    packet.vm_flags = 0;
+    packet.vm_pkt_size = size;
+    packet.vm_pkt_iov = &iov;
+    pkt_cnt = 1;
+
+    if_status = vmnet_write(s->vmnet_if, &packet, &pkt_cnt);
+    if (if_status != VMNET_SUCCESS) {
+        error_report("vmnet: write error: %s\n",
+                     vmnet_status_map_str(if_status));
+        return -1;
+    }
+
+    if (pkt_cnt) {
+        return size;
+    }
+    return 0;
+}
+
+
+/**
+ * Read packets from vmnet interface and write them
+ * to temporary buffers in VmnetState.
+ *
+ * Returns read packets number (may be 0) on success,
+ * -1 on error
+ */
+static int vmnet_read_packets(VmnetState *s)
+{
+    assert(s->packets_send_current_pos == s->packets_send_end_pos);
+
+    struct vmpktdesc *packets = s->packets_buf;
+    vmnet_return_t status;
+    int i;
+
+    /* Read as many packets as present */
+    s->packets_send_current_pos = 0;
+    s->packets_send_end_pos = VMNET_PACKETS_LIMIT;
+    for (i = 0; i < s->packets_send_end_pos; ++i) {
+        packets[i].vm_pkt_size = s->max_packet_size;
+        packets[i].vm_pkt_iovcnt = 1;
+        packets[i].vm_flags = 0;
+    }
+
+    status = vmnet_read(s->vmnet_if, packets, &s->packets_send_end_pos);
+    if (status != VMNET_SUCCESS) {
+        error_printf("vmnet: read failed: %s\n",
+                     vmnet_status_map_str(status));
+        s->packets_send_current_pos = 0;
+        s->packets_send_end_pos = 0;
+        return -1;
+    }
+    return s->packets_send_end_pos;
+}
+
+
+/**
+ * Write packets from temporary buffers in VmnetState
+ * to QEMU.
+ */
+static void vmnet_write_packets_to_qemu(VmnetState *s)
+{
+    while (s->packets_send_current_pos < s->packets_send_end_pos) {
+        ssize_t size = qemu_send_packet_async(&s->nc,
+                                      s->iov_buf[s->packets_send_current_pos].iov_base,
+                                      s->packets_buf[s->packets_send_current_pos].vm_pkt_size,
+                                      vmnet_send_completed);
+
+        if (size == 0) {
+            /* QEMU is not ready to consume more packets -
+             * stop and wait for completion callback call */
+            return;
+        }
+        ++s->packets_send_current_pos;
+    }
+}
+
+
+/**
+ * Bottom half callback that transfers packets from vmnet interface
+ * to QEMU.
+ *
+ * The process of transferring packets is three-staged:
+ * 1. Handle vmnet event;
+ * 2. Read packets from vmnet interface into temporary buffer;
+ * 3. Write packets from temporary buffer to QEMU.
+ *
+ * QEMU may suspend this process on the last stage, returning 0 from
+ * qemu_send_packet_async function. If this happens, we should
+ * respectfully wait until it is ready to consume more packets,
+ * write left ones in temporary buffer and only after this
+ * continue reading more packets from vmnet interface.
+ *
+ * Packets to be transferred are stored into packets_buf,
+ * in the window [packets_send_current_pos..packets_send_end_pos)
+ * including current_pos, excluding end_pos.
+ *
+ * Thus, if QEMU is not ready, buffer is not read and
+ * packets_send_current_pos < packets_send_end_pos.
+ */
+static void vmnet_send_bh(void *opaque)
+{
+    NetClientState *nc = (NetClientState *) opaque;
+    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
+
+    /*
+     * Do nothing if QEMU is not ready - wait
+     * for completion callback invocation
+     */
+    if (s->packets_send_current_pos < s->packets_send_end_pos) {
+        return;
+    }
+
+    /* Read packets from vmnet interface */
+    if (vmnet_read_packets(s) > 0) {
+        /* Send them to QEMU */
+        vmnet_write_packets_to_qemu(s);
+    }
+}
+
+
+/**
+ * Completion callback to be invoked by QEMU when it becomes
+ * ready to consume more packets.
+ */
+static void vmnet_send_completed(NetClientState *nc, ssize_t len)
+{
+    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
+
+    /* Callback is invoked eq queued packet is sent */
+    ++s->packets_send_current_pos;
+
+    /* Complete sending packets left in VmnetState buffers */
+    vmnet_write_packets_to_qemu(s);
+
+    /* And read new ones from vmnet if VmnetState buffer is ready */
+    if (s->packets_send_current_pos < s->packets_send_end_pos) {
+        qemu_bh_schedule(s->send_bh);
+    }
+}
+
+
+static void vmnet_bufs_init(VmnetState *s)
+{
+    struct vmpktdesc *packets = s->packets_buf;
+    struct iovec *iov = s->iov_buf;
+    int i;
+
+    for (i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
+        iov[i].iov_len = s->max_packet_size;
+        iov[i].iov_base = g_malloc0(iov[i].iov_len);
+        packets[i].vm_pkt_iov = iov + i;
+    }
+}
+
+
+int vmnet_if_create(NetClientState *nc,
+                    xpc_object_t if_desc,
+                    Error **errp)
+{
+    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
+    dispatch_semaphore_t if_created_sem = dispatch_semaphore_create(0);
+    __block vmnet_return_t if_status;
+
+    s->if_queue = dispatch_queue_create(
+        "org.qemu.vmnet.if_queue",
+        DISPATCH_QUEUE_SERIAL
+    );
+
+    xpc_dictionary_set_bool(
+        if_desc,
+        vmnet_allocate_mac_address_key,
+        false
+    );
+
+#ifdef DEBUG
+    qemu_log("vmnet.start.interface_desc:\n");
+    xpc_dictionary_apply(if_desc,
+                         ^bool(const char *k, xpc_object_t v) {
+                             char *desc = xpc_copy_description(v);
+                             qemu_log("  %s=%s\n", k, desc);
+                             free(desc);
+                             return true;
+                         });
+#endif /* DEBUG */
+
+    s->vmnet_if = vmnet_start_interface(
+        if_desc,
+        s->if_queue,
+        ^(vmnet_return_t status, xpc_object_t interface_param) {
+            if_status = status;
+            if (status != VMNET_SUCCESS || !interface_param) {
+                dispatch_semaphore_signal(if_created_sem);
+                return;
+            }
+
+#ifdef DEBUG
+            qemu_log("vmnet.start.interface_param:\n");
+            xpc_dictionary_apply(interface_param,
+                                 ^bool(const char *k, xpc_object_t v) {
+                                     char *desc = xpc_copy_description(v);
+                                     qemu_log("  %s=%s\n", k, desc);
+                                     free(desc);
+                                     return true;
+                                 });
+#endif /* DEBUG */
+
+            s->mtu = xpc_dictionary_get_uint64(
+                interface_param,
+                vmnet_mtu_key);
+            s->max_packet_size = xpc_dictionary_get_uint64(
+                interface_param,
+                vmnet_max_packet_size_key);
+
+            dispatch_semaphore_signal(if_created_sem);
+        });
+
+    if (s->vmnet_if == NULL) {
+        dispatch_release(s->if_queue);
+        dispatch_release(if_created_sem);
+        error_setg(errp,
+                   "unable to create interface with requested params");
+        return -1;
+    }
+
+    dispatch_semaphore_wait(if_created_sem, DISPATCH_TIME_FOREVER);
+    dispatch_release(if_created_sem);
+
+    if (if_status != VMNET_SUCCESS) {
+        dispatch_release(s->if_queue);
+        error_setg(errp,
+                   "cannot create vmnet interface: %s",
+                   vmnet_status_map_str(if_status));
+        return -1;
+    }
+
+    s->send_bh = aio_bh_new(qemu_get_aio_context(), vmnet_send_bh, nc);
+    vmnet_bufs_init(s);
+
+    s->packets_send_current_pos = 0;
+    s->packets_send_end_pos = 0;
+
+    vmnet_interface_set_event_callback(
+        s->vmnet_if,
+        VMNET_INTERFACE_PACKETS_AVAILABLE,
+        s->if_queue,
+        ^(interface_event_t event_id, xpc_object_t event) {
+            assert(event_id == VMNET_INTERFACE_PACKETS_AVAILABLE);
+            /*
+             * This function is being called from a non qemu thread, so
+             * we only schedule a BH, and do the rest of the io completion
+             * handling from vmnet_send_bh() which runs in a qemu context.
+             */
+            qemu_bh_schedule(s->send_bh);
+        });
+
+    return 0;
+}
+
+
+void vmnet_cleanup_common(NetClientState *nc)
+{
+    VmnetState *s = DO_UPCAST(VmnetState, nc, nc);
+    dispatch_semaphore_t if_stopped_sem;
+
+    if (s->vmnet_if == NULL) {
+        return;
+    }
+
+    if_stopped_sem = dispatch_semaphore_create(0);
+    vmnet_stop_interface(
+        s->vmnet_if,
+        s->if_queue,
+        ^(vmnet_return_t status) {
+            assert(status == VMNET_SUCCESS);
+            dispatch_semaphore_signal(if_stopped_sem);
+        });
+    dispatch_semaphore_wait(if_stopped_sem, DISPATCH_TIME_FOREVER);
+
+    qemu_purge_queued_packets(nc);
+
+    qemu_bh_delete(s->send_bh);
+    dispatch_release(if_stopped_sem);
+    dispatch_release(s->if_queue);
+
+    for (int i = 0; i < VMNET_PACKETS_LIMIT; ++i) {
+        g_free(s->iov_buf[i].iov_base);
+    }
+}
diff --git a/net/vmnet-shared.c b/net/vmnet-shared.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vmnet-shared.c
+++ b/net/vmnet-shared.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "qapi/qapi-types-net.h"
+#include "qapi/error.h"
 #include "vmnet_int.h"
 #include "clients.h"
-#include "qemu/error-report.h"
-#include "qapi/error.h"
 
 #include <vmnet/vmnet.h>
 
+
+static bool validate_options(const Netdev *netdev, Error **errp)
+{
+    const NetdevVmnetSharedOptions *options = &(netdev->u.vmnet_shared);
+
+#if !defined(MAC_OS_VERSION_11_0) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_11_0
+    if (options->has_isolated) {
+        error_setg(errp,
+                   "vmnet-shared.isolated feature is "
+                   "unavailable: outdated vmnet.framework API");
+        return false;
+    }
+#endif
+
+    if ((options->has_start_address ||
+         options->has_end_address ||
+         options->has_subnet_mask) &&
+        !(options->has_start_address &&
+          options->has_end_address &&
+          options->has_subnet_mask)) {
+        error_setg(errp,
+                   "'start-address', 'end-address', 'subnet-mask' "
+                   "should be provided together"
+        );
+        return false;
+    }
+
+    return true;
+}
+
+static xpc_object_t build_if_desc(const Netdev *netdev)
+{
+    const NetdevVmnetSharedOptions *options = &(netdev->u.vmnet_shared);
+    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
+
+    xpc_dictionary_set_uint64(
+        if_desc,
+        vmnet_operation_mode_key,
+        VMNET_SHARED_MODE
+    );
+
+    if (options->has_nat66_prefix) {
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_nat66_prefix_key,
+                                  options->nat66_prefix);
+    }
+
+    if (options->has_start_address) {
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_start_address_key,
+                                  options->start_address);
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_end_address_key,
+                                  options->end_address);
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_subnet_mask_key,
+                                  options->subnet_mask);
+    }
+
+#if defined(MAC_OS_VERSION_11_0) && \
+    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
+    xpc_dictionary_set_bool(
+        if_desc,
+        vmnet_enable_isolation_key,
+        options->isolated
+    );
+#endif
+
+    return if_desc;
+}
+
+static NetClientInfo net_vmnet_shared_info = {
+    .type = NET_CLIENT_DRIVER_VMNET_SHARED,
+    .size = sizeof(VmnetState),
+    .receive = vmnet_receive_common,
+    .cleanup = vmnet_cleanup_common,
+};
+
 int net_init_vmnet_shared(const Netdev *netdev, const char *name,
                           NetClientState *peer, Error **errp)
 {
-  error_setg(errp, "vmnet-shared is not implemented yet");
-  return -1;
+    NetClientState *nc = qemu_new_net_client(&net_vmnet_shared_info,
+                                             peer, "vmnet-shared", name);
+    xpc_object_t if_desc;
+    int result = -1;
+
+    if (!validate_options(netdev, errp)) {
+        return result;
+    }
+
+    if_desc = build_if_desc(netdev);
+    result = vmnet_if_create(nc, if_desc, errp);
+    xpc_release(if_desc);
+    return result;
 }
diff --git a/net/vmnet_int.h b/net/vmnet_int.h
index XXXXXXX..XXXXXXX 100644
--- a/net/vmnet_int.h
+++ b/net/vmnet_int.h
@@ -XXX,XX +XXX,XX @@
 #include "clients.h"
 
 #include <vmnet/vmnet.h>
+#include <dispatch/dispatch.h>
+
+/**
+ *  From vmnet.framework documentation
+ *
+ *  Each read/write call allows up to 200 packets to be
+ *  read or written for a maximum of 256KB.
+ *
+ *  Each packet written should be a complete
+ *  ethernet frame.
+ *
+ *  https://developer.apple.com/documentation/vmnet
+ */
+#define VMNET_PACKETS_LIMIT 200
 
 typedef struct VmnetState {
-  NetClientState nc;
+    NetClientState nc;
+    interface_ref vmnet_if;
+
+    uint64_t mtu;
+    uint64_t max_packet_size;
 
+    dispatch_queue_t if_queue;
+
+    QEMUBH *send_bh;
+
+    struct vmpktdesc packets_buf[VMNET_PACKETS_LIMIT];
+    int packets_send_current_pos;
+    int packets_send_end_pos;
+
+    struct iovec iov_buf[VMNET_PACKETS_LIMIT];
 } VmnetState;
 
+const char *vmnet_status_map_str(vmnet_return_t status);
+
+int vmnet_if_create(NetClientState *nc,
+                    xpc_object_t if_desc,
+                    Error **errp);
+
+ssize_t vmnet_receive_common(NetClientState *nc,
+                             const uint8_t *buf,
+                             size_t size);
+
+void vmnet_cleanup_common(NetClientState *nc);
 
 #endif /* VMNET_INT_H */
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/vmnet-host.c | 116 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 110 insertions(+), 6 deletions(-)

diff --git a/net/vmnet-host.c b/net/vmnet-host.c
index XXXXXXX..XXXXXXX 100644
--- a/net/vmnet-host.c
+++ b/net/vmnet-host.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "qemu/uuid.h"
 #include "qapi/qapi-types-net.h"
-#include "vmnet_int.h"
-#include "clients.h"
-#include "qemu/error-report.h"
 #include "qapi/error.h"
+#include "clients.h"
+#include "vmnet_int.h"
 
 #include <vmnet/vmnet.h>
 
+
+static bool validate_options(const Netdev *netdev, Error **errp)
+{
+    const NetdevVmnetHostOptions *options = &(netdev->u.vmnet_host);
+
+#if defined(MAC_OS_VERSION_11_0) && \
+    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
+
+    QemuUUID net_uuid;
+    if (options->has_net_uuid &&
+        qemu_uuid_parse(options->net_uuid, &net_uuid) < 0) {
+        error_setg(errp, "Invalid UUID provided in 'net-uuid'");
+        return false;
+    }
+#else
+    if (options->has_isolated) {
+        error_setg(errp,
+                   "vmnet-host.isolated feature is "
+                   "unavailable: outdated vmnet.framework API");
+        return false;
+    }
+
+    if (options->has_net_uuid) {
+        error_setg(errp,
+                   "vmnet-host.net-uuid feature is "
+                   "unavailable: outdated vmnet.framework API");
+        return false;
+    }
+#endif
+
+    if ((options->has_start_address ||
+         options->has_end_address ||
+         options->has_subnet_mask) &&
+        !(options->has_start_address &&
+          options->has_end_address &&
+          options->has_subnet_mask)) {
+        error_setg(errp,
+                   "'start-address', 'end-address', 'subnet-mask' "
+                   "should be provided together");
+        return false;
+    }
+
+    return true;
+}
+
+static xpc_object_t build_if_desc(const Netdev *netdev)
+{
+    const NetdevVmnetHostOptions *options = &(netdev->u.vmnet_host);
+    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
+
+    xpc_dictionary_set_uint64(if_desc,
+                              vmnet_operation_mode_key,
+                              VMNET_HOST_MODE);
+
+#if defined(MAC_OS_VERSION_11_0) && \
+    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
+
+    xpc_dictionary_set_bool(if_desc,
+                            vmnet_enable_isolation_key,
+                            options->isolated);
+
+    QemuUUID net_uuid;
+    if (options->has_net_uuid) {
+        qemu_uuid_parse(options->net_uuid, &net_uuid);
+        xpc_dictionary_set_uuid(if_desc,
+                                vmnet_network_identifier_key,
+                                net_uuid.data);
+    }
+#endif
+
+    if (options->has_start_address) {
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_start_address_key,
+                                  options->start_address);
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_end_address_key,
+                                  options->end_address);
+        xpc_dictionary_set_string(if_desc,
+                                  vmnet_subnet_mask_key,
+                                  options->subnet_mask);
+    }
+
+    return if_desc;
+}
+
+static NetClientInfo net_vmnet_host_info = {
+    .type = NET_CLIENT_DRIVER_VMNET_HOST,
+    .size = sizeof(VmnetState),
+    .receive = vmnet_receive_common,
+    .cleanup = vmnet_cleanup_common,
+};
+
 int net_init_vmnet_host(const Netdev *netdev, const char *name,
-                        NetClientState *peer, Error **errp) {
-  error_setg(errp, "vmnet-host is not implemented yet");
-  return -1;
+                        NetClientState *peer, Error **errp)
+{
+    NetClientState *nc = qemu_new_net_client(&net_vmnet_host_info,
+                                             peer, "vmnet-host", name);
+    xpc_object_t if_desc;
+    int result = -1;
+
+    if (!validate_options(netdev, errp)) {
+        return result;
+    }
+
+    if_desc = build_if_desc(netdev);
+    result = vmnet_if_create(nc, if_desc, errp);
+    xpc_release(if_desc);
+    return result;
 }
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 net/vmnet-bridged.m | 137 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 132 insertions(+), 5 deletions(-)

diff --git a/net/vmnet-bridged.m b/net/vmnet-bridged.m
index XXXXXXX..XXXXXXX 100644
--- a/net/vmnet-bridged.m
+++ b/net/vmnet-bridged.m
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "qapi/qapi-types-net.h"
-#include "vmnet_int.h"
-#include "clients.h"
-#include "qemu/error-report.h"
 #include "qapi/error.h"
+#include "clients.h"
+#include "vmnet_int.h"
 
 #include <vmnet/vmnet.h>
 
+
+static bool validate_ifname(const char *ifname)
+{
+    xpc_object_t shared_if_list = vmnet_copy_shared_interface_list();
+    bool match = false;
+    if (!xpc_array_get_count(shared_if_list)) {
+        goto done;
+    }
+
+    match = !xpc_array_apply(
+        shared_if_list,
+        ^bool(size_t index, xpc_object_t value) {
+            return strcmp(xpc_string_get_string_ptr(value), ifname) != 0;
+        });
+
+done:
+    xpc_release(shared_if_list);
+    return match;
+}
+
+
+static char* get_valid_ifnames()
+{
+    xpc_object_t shared_if_list = vmnet_copy_shared_interface_list();
+    __block char *if_list = NULL;
+    __block char *if_list_prev = NULL;
+
+    if (!xpc_array_get_count(shared_if_list)) {
+        goto done;
+    }
+
+    xpc_array_apply(
+        shared_if_list,
+        ^bool(size_t index, xpc_object_t value) {
+            /* build list of strings like "en0 en1 en2 " */
+            if_list = g_strconcat(xpc_string_get_string_ptr(value),
+                                  " ",
+                                  if_list_prev,
+                                  NULL);
+            g_free(if_list_prev);
+            if_list_prev = if_list;
+            return true;
+        });
+
+done:
+    xpc_release(shared_if_list);
+    return if_list;
+}
+
+
+static bool validate_options(const Netdev *netdev, Error **errp)
+{
+    const NetdevVmnetBridgedOptions *options = &(netdev->u.vmnet_bridged);
+    char* if_list;
+
+    if (!validate_ifname(options->ifname)) {
+        if_list = get_valid_ifnames();
+        if (if_list) {
+            error_setg(errp,
+                       "unsupported ifname '%s', expected one of [ %s]",
+                       options->ifname,
+                       if_list);
+            g_free(if_list);
+        } else {
+            error_setg(errp,
+                       "unsupported ifname '%s', no supported "
+                       "interfaces available",
+                       options->ifname);
+        }
+        return false;
+    }
+
+#if !defined(MAC_OS_VERSION_11_0) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_11_0
+    if (options->has_isolated) {
+        error_setg(errp,
+                   "vmnet-bridged.isolated feature is "
+                   "unavailable: outdated vmnet.framework API");
+        return false;
+    }
+#endif
+    return true;
+}
+
+
+static xpc_object_t build_if_desc(const Netdev *netdev)
+{
+    const NetdevVmnetBridgedOptions *options = &(netdev->u.vmnet_bridged);
+    xpc_object_t if_desc = xpc_dictionary_create(NULL, NULL, 0);
+
+    xpc_dictionary_set_uint64(if_desc,
+                              vmnet_operation_mode_key,
+                              VMNET_BRIDGED_MODE
+    );
+
+    xpc_dictionary_set_string(if_desc,
+                              vmnet_shared_interface_name_key,
+                              options->ifname);
+
+#if defined(MAC_OS_VERSION_11_0) && \
+    MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
+    xpc_dictionary_set_bool(if_desc,
+                            vmnet_enable_isolation_key,
+                            options->isolated);
+#endif
+    return if_desc;
+}
+
+
+static NetClientInfo net_vmnet_bridged_info = {
+    .type = NET_CLIENT_DRIVER_VMNET_BRIDGED,
+    .size = sizeof(VmnetState),
+    .receive = vmnet_receive_common,
+    .cleanup = vmnet_cleanup_common,
+};
+
+
 int net_init_vmnet_bridged(const Netdev *netdev, const char *name,
                            NetClientState *peer, Error **errp)
 {
-  error_setg(errp, "vmnet-bridged is not implemented yet");
-  return -1;
+    NetClientState *nc = qemu_new_net_client(&net_vmnet_bridged_info,
+                                             peer, "vmnet-bridged", name);
+    xpc_object_t if_desc;
+    int result = -1;
+
+    if (!validate_options(netdev, errp)) {
+        return result;
+    }
+
+    if_desc = build_if_desc(netdev);
+    result = vmnet_if_create(nc, if_desc, errp);
+    xpc_release(if_desc);
+    return result;
 }
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Update qemu-options.hx to support vmnet networking backend.

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 qemu-options.hx | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

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,
 #ifdef __linux__
     "-netdev vhost-vdpa,id=str,vhostdev=/path/to/dev\n"
     "                configure a vhost-vdpa network,Establish a vhost-vdpa netdev\n"
+#endif
+#ifdef CONFIG_VMNET
+    "-netdev vmnet-host,id=str[,isolated=on|off][,net-uuid=uuid]\n"
+    "         [,start-address=addr,end-address=addr,subnet-mask=mask]\n"
+    "                configure a vmnet network backend in host mode with ID 'str',\n"
+    "                isolate this interface from others with 'isolated',\n"
+    "                configure the address range and choose a subnet mask,\n"
+    "                specify network UUID 'uuid' to disable DHCP and interact with\n"
+    "                vmnet-host interfaces within this isolated network\n"
+    "-netdev vmnet-shared,id=str[,isolated=on|off][,nat66-prefix=addr]\n"
+    "         [,start-address=addr,end-address=addr,subnet-mask=mask]\n"
+    "                configure a vmnet network backend in shared mode with ID 'str',\n"
+    "                configure the address range and choose a subnet mask,\n"
+    "                set IPv6 ULA prefix (of length 64) to use for internal network,\n"
+    "                isolate this interface from others with 'isolated'\n"
+    "-netdev vmnet-bridged,id=str,ifname=name[,isolated=on|off]\n"
+    "                configure a vmnet network backend in bridged mode with ID 'str',\n"
+    "                use 'ifname=name' to select a physical network interface to be bridged,\n"
+    "                isolate this interface from others with 'isolated'\n"
 #endif
     "-netdev hubport,id=str,hubid=n[,netdev=nd]\n"
     "                configure a hub port on the hub with ID 'n'\n", QEMU_ARCH_ALL)
@@ -XXX,XX +XXX,XX @@ DEF("nic", HAS_ARG, QEMU_OPTION_nic,
 #endif
 #ifdef CONFIG_POSIX
     "vhost-user|"
+#endif
+#ifdef CONFIG_VMNET
+    "vmnet-host|vmnet-shared|vmnet-bridged|"
 #endif
     "socket][,option][,...][mac=macaddr]\n"
     "                initialize an on-board / default host NIC (using MAC address\n"
@@ -XXX,XX +XXX,XX @@ DEF("net", HAS_ARG, QEMU_OPTION_net,
 #endif
 #ifdef CONFIG_NETMAP
     "netmap|"
+#endif
+#ifdef CONFIG_VMNET
+    "vmnet-host|vmnet-shared|vmnet-bridged|"
 #endif
     "socket][,option][,option][,...]\n"
     "                old way to initialize a host network interface\n"
-- 
2.25.1

From: Vladislav Yaroshchuk <vladislav.yaroshchuk@jetbrains.com>

Update HMP for supporting vmnet.

Reviewed-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Tested-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Signed-off-by: Vladislav Yaroshchuk <Vladislav.Yaroshchuk@jetbrains.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hmp-commands.hx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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],id=str[,prop=value][,...]",
+        .params     = "[user|tap|socket|vde|bridge|hubport|netmap|vhost-user"
+#ifdef CONFIG_VMNET
+                      "|vmnet-host|vmnet-shared|vmnet-bridged"
+#endif
+                      "],id=str[,prop=value][,...]",
         .help       = "add host network device",
         .cmd        = hmp_netdev_add,
         .command_completion = netdev_add_completion,
-- 
2.25.1

From: Helge Deller <deller@gmx.de>

The MAC of the tulip card is stored in the EEPROM and at startup
tulip_fill_eeprom() is called to initialize the EEPROM with the MAC
address given on the command line, e.g.:
    -device tulip,mac=00:11:22:33:44:55

In case the mac address was not given on the command line,
tulip_fill_eeprom() initializes the MAC in EEPROM with 00:00:00:00:00:00
which breaks e.g. a HP-UX guest.

Fix this problem by moving qemu_macaddr_default_if_unset() a few lines
up, so that a default mac address is assigned before tulip_fill_eeprom()
initializes the EEPROM.

Signed-off-by: Helge Deller <deller@gmx.de>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Jason Wang <jasowang@redhat.com>
---
 hw/net/tulip.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/net/tulip.c b/hw/net/tulip.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/tulip.c
+++ b/hw/net/tulip.c
@@ -XXX,XX +XXX,XX @@ static void pci_tulip_realize(PCIDevice *pci_dev, Error **errp)
     pci_conf = s->dev.config;
     pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */
 
+    qemu_macaddr_default_if_unset(&s->c.macaddr);
+
     s->eeprom = eeprom93xx_new(&pci_dev->qdev, 64);
     tulip_fill_eeprom(s);
 
@@ -XXX,XX +XXX,XX @@ static void pci_tulip_realize(PCIDevice *pci_dev, Error **errp)
 
     s->irq = pci_allocate_irq(&s->dev);
 
-    qemu_macaddr_default_if_unset(&s->c.macaddr);
-
     s->nic = qemu_new_nic(&net_tulip_info, &s->c,
                           object_get_typename(OBJECT(pci_dev)),
                           pci_dev->qdev.id, s);
-- 
2.25.1