* [PATCH v19 01/15] net/tap: rework tap_parse_script
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 02/15] net/tap: improve script/downscript options documentation Vladimir Sementsov-Ogievskiy
` (15 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
Factor out tap_is_explicit_no_script() helper, to simplify
further changes.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
net/tap.c | 27 +++++++++++++++++++++------
1 file changed, 21 insertions(+), 6 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index 57ffb09885c..fedd48c48d2 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -92,19 +92,34 @@ static void launch_script(const char *setup_script, const char *ifname,
static void tap_send(void *opaque);
static void tap_writable(void *opaque);
-static char *tap_parse_script(const char *script_arg, const char *default_path)
+static bool tap_is_explicit_no_script(const char *script_arg)
{
- g_autofree char *res = g_strdup(script_arg);
+ if (!script_arg) {
+ return false;
+ }
- if (!res) {
- res = get_relocated_path(default_path);
+ if (script_arg[0] == '\0') {
+ return true;
+ }
+
+ if (strcmp(script_arg, "no") == 0) {
+ return true;
}
- if (res[0] == '\0' || strcmp(res, "no") == 0) {
+ return false;
+}
+
+static char *tap_parse_script(const char *script_arg, const char *default_path)
+{
+ if (tap_is_explicit_no_script(script_arg)) {
return NULL;
}
- return g_steal_pointer(&res);
+ if (!script_arg) {
+ return get_relocated_path(default_path);
+ }
+
+ return g_strdup(script_arg);
}
static void tap_update_fd_handler(TAPState *s)
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 02/15] net/tap: improve script/downscript options documentation
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 01/15] net/tap: rework tap_parse_script Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 03/15] net/tap: deprecate "no" as special value for script/downscript Vladimir Sementsov-Ogievskiy
` (14 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Eric Blake, Jason Wang
Properly document defaults and special values of "" and "no".
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
---
qapi/net.json | 12 +++++++++---
qemu-options.hx | 9 +++++----
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/qapi/net.json b/qapi/net.json
index 1a6382825c5..8f0915c4d86 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -399,9 +399,15 @@
# @fds: multiple file descriptors of already opened multiqueue capable
# tap
#
-# @script: script to initialize the interface
-#
-# @downscript: script to shut down the interface
+# @script: script to initialize the interface. An empty string or
+# "no" disables script execution. Defaults to
+# ``<sysconfdir>/qemu-ifup``, where ``<sysconfdir>`` is the
+# system configuration directory at build time (typically /etc).
+#
+# @downscript: script to shut down the interface. An empty string or
+# "no" disables script execution. Defaults to
+# ``<sysconfdir>/qemu-ifdown``, where ``<sysconfdir>`` is the
+# system configuration directory at build time (typically /etc).
#
# @br: bridge name (since 2.8)
#
diff --git a/qemu-options.hx b/qemu-options.hx
index 34970fffc94..200949655ea 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -3014,7 +3014,7 @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
" use network scripts 'file' (default=" DEFAULT_NETWORK_SCRIPT ")\n"
" to configure it and 'dfile' (default=" DEFAULT_NETWORK_DOWN_SCRIPT ")\n"
" to deconfigure it\n"
- " use '[down]script=no' to disable script execution\n"
+ " use '[down]script=no' or '[down]script=' to disable script execution\n"
" use network helper 'helper' (default=" DEFAULT_BRIDGE_HELPER ") to\n"
" configure it\n"
" use 'fd=h' to connect to an already opened TAP interface\n"
@@ -3550,9 +3550,10 @@ SRST
Use the network script file to configure it and the network script
dfile to deconfigure it. If name is not provided, the OS
automatically provides one. The default network configure script is
- ``/etc/qemu-ifup`` and the default network deconfigure script is
- ``/etc/qemu-ifdown``. Use ``script=no`` or ``downscript=no`` to
- disable script execution.
+ ``<sysconfdir>/qemu-ifup`` and the default network deconfigure script is
+ ``<sysconfdir>/qemu-ifdown``, where ``<sysconfdir>`` is the system
+ configuration directory at build time (typically ``/etc``).
+ Use ``[down]script=no`` or ``[down]script=`` to disable script execution.
If running QEMU as an unprivileged user, use the network helper
to configure the TAP interface and attach it to the bridge.
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 03/15] net/tap: deprecate "no" as special value for script/downscript
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 01/15] net/tap: rework tap_parse_script Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 02/15] net/tap: improve script/downscript options documentation Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 04/15] net/tap: move vhost-net open() calls to tap_parse_vhost_fds() Vladimir Sementsov-Ogievskiy
` (13 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Pierrick Bouvier, Sergio Lopez, Zhao Liu, Stefano Stabellini,
Anthony PERARD, Edgar E. Iglesias, Bernhard Beschow,
Alistair Francis, Palmer Dabbelt, Jason Wang, Eric Blake,
open list:Incompatible changes, open list:X86 Xen CPUs,
open list:e500, open list:Microchip PolarFi...
The interface is ambiguous, as "no" is valid file name. So,
using "no" as a special value to disable script is deprecated.
Use an empty string ("script=" / "downscript=") instead.
In a future version, "no" will be treated as a plain file name, just
like any other non-empty value.
Document the deprecation in docs/about/deprecated.rst, qapi/net.json,
and qemu-options.hx. Update other docs to use empty string instead of
"no". Add a warning.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
docs/about/deprecated.rst | 18 ++++++++++++++
docs/system/i386/microvm.rst | 4 +--
docs/system/i386/xenpvh.rst | 2 +-
docs/system/ppc/ppce500.rst | 4 +--
docs/system/riscv/microchip-icicle-kit.rst | 2 +-
docs/system/riscv/sifive_u.rst | 2 +-
net/tap.c | 29 ++++++++++++++--------
qapi/net.json | 12 ++++++---
qemu-options.hx | 7 ++++--
9 files changed, 56 insertions(+), 24 deletions(-)
diff --git a/docs/about/deprecated.rst b/docs/about/deprecated.rst
index 0c656a968fc..c4929317e3a 100644
--- a/docs/about/deprecated.rst
+++ b/docs/about/deprecated.rst
@@ -71,6 +71,15 @@ flexible enough. The monitor objects have been converted to QOM, so
``-mon mode=control`` is replaced by ``-object monitor-qmp``. The
short convenience options are not deprecated, only ``-mon``.
+``script=no`` and ``downscript=no`` for ``-netdev tap`` (since 11.2)
+'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+The special value ``"no"`` for the ``script`` and ``downscript``
+parameters of ``-netdev tap`` disables script execution. This special
+treatment of ``"no"`` is deprecated. Use an empty string (``script=``
+or ``downscript=``) to disable script execution instead. In a future
+version, ``"no"`` will be treated as a plain file name.
+
QEMU Machine Protocol (QMP) commands
------------------------------------
@@ -164,6 +173,15 @@ Use ``job-finalize`` instead.
Use ``query-accelerators`` instead.
+``"no"`` as value of ``script``/``downscript`` for tap in ``netdev_add`` (since 11.2)
+'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+The special value ``"no"`` for the ``script`` and ``downscript``
+parameters of ``netdev_add`` with ``type=tap`` disables script
+execution. This special treatment of ``"no"`` is deprecated. Use an
+empty string instead. In a future version, ``"no"`` will be treated as
+a plain file name.
+
Human Machine Protocol (HMP) commands
-------------------------------------
diff --git a/docs/system/i386/microvm.rst b/docs/system/i386/microvm.rst
index 1675e37d3e7..077ea15751e 100644
--- a/docs/system/i386/microvm.rst
+++ b/docs/system/i386/microvm.rst
@@ -79,7 +79,7 @@ legacy ``ISA serial`` device as console::
-serial stdio \
-drive id=test,file=test.img,format=raw,if=none \
-device virtio-blk-device,drive=test \
- -netdev tap,id=tap0,script=no,downscript=no \
+ -netdev tap,id=tap0,script=,downscript= \
-device virtio-net-device,netdev=tap0
While the example above works, you might be interested in reducing the
@@ -103,7 +103,7 @@ disabled::
-device virtconsole,chardev=virtiocon0 \
-drive id=test,file=test.img,format=raw,if=none \
-device virtio-blk-device,drive=test \
- -netdev tap,id=tap0,script=no,downscript=no \
+ -netdev tap,id=tap0,script=,downscript= \
-device virtio-net-device,netdev=tap0
diff --git a/docs/system/i386/xenpvh.rst b/docs/system/i386/xenpvh.rst
index 904778e3f5c..862f38830b1 100644
--- a/docs/system/i386/xenpvh.rst
+++ b/docs/system/i386/xenpvh.rst
@@ -42,7 +42,7 @@ case you need to construct one manually:
-vnc none \
-display none \
-device virtio-net-pci,id=nic0,netdev=net0,mac=00:16:3e:5c:81:78 \
- -netdev type=tap,id=net0,ifname=vif3.0-emu,br=xenbr0,script=no,downscript=no \
+ -netdev type=tap,id=net0,ifname=vif3.0-emu,br=xenbr0,script=,downscript= \
-smp 4,maxcpus=4 \
-nographic \
-machine xenpvh,ram-low-base=0,ram-low-size=2147483648,ram-high-base=4294967296,ram-high-size=2147483648,pci-ecam-base=824633720832,pci-ecam-size=268435456,pci-mmio-base=4026531840,pci-mmio-size=33554432,pci-mmio-high-base=824902156288,pci-mmio-high-size=68719476736 \
diff --git a/docs/system/ppc/ppce500.rst b/docs/system/ppc/ppce500.rst
index c9fe0915dc5..ec5aaf14fd9 100644
--- a/docs/system/ppc/ppce500.rst
+++ b/docs/system/ppc/ppce500.rst
@@ -158,14 +158,14 @@ interface at PCI address 0.1.0, but we can switch that to an e1000 NIC by:
$ qemu-system-ppc64 -M ppce500 -smp 4 -m 2G \
-display none -serial stdio \
-bios u-boot \
- -nic tap,ifname=tap0,script=no,downscript=no,model=e1000
+ -nic tap,ifname=tap0,script=,downscript=,model=e1000
The QEMU ``ppce500`` machine can also dynamically instantiate an eTSEC device
if “-device eTSEC” is given to QEMU:
.. code-block:: bash
- -netdev tap,ifname=tap0,script=no,downscript=no,id=net0 -device eTSEC,netdev=net0
+ -netdev tap,ifname=tap0,script=,downscript=,id=net0 -device eTSEC,netdev=net0
Root file system on flash drive
-------------------------------
diff --git a/docs/system/riscv/microchip-icicle-kit.rst b/docs/system/riscv/microchip-icicle-kit.rst
index 9809e94b84b..7fdb96601ad 100644
--- a/docs/system/riscv/microchip-icicle-kit.rst
+++ b/docs/system/riscv/microchip-icicle-kit.rst
@@ -84,7 +84,7 @@ Then we can boot the machine by:
$ qemu-system-riscv64 -M microchip-icicle-kit -smp 5 -m 2G \
-sd path/to/sdcard.img \
-nic user,model=cadence_gem \
- -nic tap,ifname=tap,model=cadence_gem,script=no \
+ -nic tap,ifname=tap,model=cadence_gem,script= \
-display none -serial stdio \
-kernel path/to/u-boot/build/dir/u-boot.bin \
-dtb path/to/u-boot/build/dir/u-boot.dtb
diff --git a/docs/system/riscv/sifive_u.rst b/docs/system/riscv/sifive_u.rst
index 8f55ae8e313..0e4dcf3e70c 100644
--- a/docs/system/riscv/sifive_u.rst
+++ b/docs/system/riscv/sifive_u.rst
@@ -199,7 +199,7 @@ To boot the VxWorks kernel in QEMU with the ``sifive_u`` machine, use:
$ qemu-system-riscv64 -M sifive_u -smp 5 -m 2G \
-display none -serial stdio \
- -nic tap,ifname=tap0,script=no,downscript=no \
+ -nic tap,ifname=tap0,script=,downscript= \
-kernel /path/to/vxWorks \
-append "gem(0,0)host:vxWorks h=192.168.200.1 e=192.168.200.2:ffffff00 u=target pw=vxTarget f=0x01"
diff --git a/net/tap.c b/net/tap.c
index fedd48c48d2..2e94b4015f6 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -92,34 +92,40 @@ static void launch_script(const char *setup_script, const char *ifname,
static void tap_send(void *opaque);
static void tap_writable(void *opaque);
-static bool tap_is_explicit_no_script(const char *script_arg)
+static bool tap_is_explicit_no_script(const char *script_arg_name,
+ const char *script_arg_value)
{
- if (!script_arg) {
+ if (!script_arg_value) {
return false;
}
- if (script_arg[0] == '\0') {
+ if (script_arg_value[0] == '\0') {
return true;
}
- if (strcmp(script_arg, "no") == 0) {
+ if (strcmp(script_arg_value, "no") == 0) {
+ warn_report("%s=no is deprecated; use %s= instead "
+ "(empty string instead of 'no')",
+ script_arg_name, script_arg_name);
return true;
}
return false;
}
-static char *tap_parse_script(const char *script_arg, const char *default_path)
+static char *tap_parse_script(const char *script_arg_name,
+ const char *script_arg_value,
+ const char *default_path)
{
- if (tap_is_explicit_no_script(script_arg)) {
+ if (tap_is_explicit_no_script(script_arg_name, script_arg_value)) {
return NULL;
}
- if (!script_arg) {
+ if (!script_arg_value) {
return get_relocated_path(default_path);
}
- return g_strdup(script_arg);
+ return g_strdup(script_arg_value);
}
static void tap_update_fd_handler(TAPState *s)
@@ -740,7 +746,7 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
qemu_set_info_str(&s->nc, "helper=%s", tap->helper);
} else {
qemu_set_info_str(&s->nc, "ifname=%s,script=%s,downscript=%s", ifname,
- script ?: "no", downscript ?: "no");
+ script ?: "", downscript ?: "");
if (downscript) {
snprintf(s->down_script, sizeof(s->down_script), "%s", downscript);
@@ -946,9 +952,10 @@ int net_init_tap(const Netdev *netdev, const char *name,
}
} else {
g_autofree char *script =
- tap_parse_script(tap->script, DEFAULT_NETWORK_SCRIPT);
+ tap_parse_script("script", tap->script, DEFAULT_NETWORK_SCRIPT);
g_autofree char *downscript =
- tap_parse_script(tap->downscript, DEFAULT_NETWORK_DOWN_SCRIPT);
+ tap_parse_script("downscript", tap->downscript,
+ DEFAULT_NETWORK_DOWN_SCRIPT);
if (tap->ifname) {
pstrcpy(ifname, sizeof ifname, tap->ifname);
diff --git a/qapi/net.json b/qapi/net.json
index 8f0915c4d86..ada0329ef9d 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -399,15 +399,19 @@
# @fds: multiple file descriptors of already opened multiqueue capable
# tap
#
-# @script: script to initialize the interface. An empty string or
-# "no" disables script execution. Defaults to
+# @script: script to initialize the interface. An empty string
+# disables script execution. Defaults to
# ``<sysconfdir>/qemu-ifup``, where ``<sysconfdir>`` is the
# system configuration directory at build time (typically /etc).
+# Using "no" to disable script execution is deprecated (since
+# 11.2); use an empty string instead.
#
-# @downscript: script to shut down the interface. An empty string or
-# "no" disables script execution. Defaults to
+# @downscript: script to shut down the interface. An empty string
+# disables script execution. Defaults to
# ``<sysconfdir>/qemu-ifdown``, where ``<sysconfdir>`` is the
# system configuration directory at build time (typically /etc).
+# Using "no" to disable script execution is deprecated (since
+# 11.2); use an empty string instead.
#
# @br: bridge name (since 2.8)
#
diff --git a/qemu-options.hx b/qemu-options.hx
index 200949655ea..7b9a14f5b38 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -3014,7 +3014,8 @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,
" use network scripts 'file' (default=" DEFAULT_NETWORK_SCRIPT ")\n"
" to configure it and 'dfile' (default=" DEFAULT_NETWORK_DOWN_SCRIPT ")\n"
" to deconfigure it\n"
- " use '[down]script=no' or '[down]script=' to disable script execution\n"
+ " use '[down]script=' to disable script execution\n"
+ " ('[down]script=no' is deprecated and will be treated as a file name in future)\n"
" use network helper 'helper' (default=" DEFAULT_BRIDGE_HELPER ") to\n"
" configure it\n"
" use 'fd=h' to connect to an already opened TAP interface\n"
@@ -3553,7 +3554,9 @@ SRST
``<sysconfdir>/qemu-ifup`` and the default network deconfigure script is
``<sysconfdir>/qemu-ifdown``, where ``<sysconfdir>`` is the system
configuration directory at build time (typically ``/etc``).
- Use ``[down]script=no`` or ``[down]script=`` to disable script execution.
+ Use ``[down]script=`` to disable script execution.
+ Using ``[down]script=no`` is deprecated; in a future version it will
+ be treated as a plain file name.
If running QEMU as an unprivileged user, use the network helper
to configure the TAP interface and attach it to the bridge.
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 04/15] net/tap: move vhost-net open() calls to tap_parse_vhost_fds()
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (2 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 03/15] net/tap: deprecate "no" as special value for script/downscript Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 05/15] net/tap: move vhost initialization to tap_setup_vhost() Vladimir Sementsov-Ogievskiy
` (12 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
1. Simplify code path: get vhostfds for all cases in one function.
2. Prepare for further tap-fd-migraton feature, when we'll need to
postpone vhost initialization up to post-load stage.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Ben Chaney <bchaney@akamai.com>
---
net/tap.c | 39 ++++++++++++++++++++++-----------------
1 file changed, 22 insertions(+), 17 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index 2e94b4015f6..dcc914ffdf2 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -757,8 +757,7 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
}
}
- if (tap->has_vhost ? tap->vhost :
- (vhostfd != -1) || (tap->has_vhostforce && tap->vhostforce)) {
+ if (vhostfd != -1) {
VhostNetOptions options;
options.backend_type = VHOST_BACKEND_TYPE_KERNEL;
@@ -768,17 +767,6 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
} else {
options.busyloop_timeout = 0;
}
-
- if (vhostfd == -1) {
- vhostfd = open("/dev/vhost-net", O_RDWR);
- if (vhostfd < 0) {
- error_setg_file_open(errp, errno, "/dev/vhost-net");
- goto failed;
- }
- if (!qemu_set_blocking(vhostfd, false, errp)) {
- goto failed;
- }
- }
options.opaque = (void *)(uintptr_t)vhostfd;
options.nvqs = 2;
options.feature_bits = kernel_feature_bits;
@@ -864,14 +852,31 @@ static int tap_parse_fds_and_queues(const NetdevTapOptions *tap, int **fds,
static bool tap_parse_vhost_fds(const NetdevTapOptions *tap, int **vhost_fds,
int queues, Error **errp)
{
- if (!(tap->vhostfd || tap->vhostfds)) {
+ bool need_vhost = tap->has_vhost ? tap->vhost :
+ ((tap->vhostfd || tap->vhostfds) ||
+ (tap->has_vhostforce && tap->vhostforce));
+
+ if (!need_vhost) {
*vhost_fds = NULL;
return true;
}
- if (net_parse_fds(tap->vhostfd ?: tap->vhostfds,
- vhost_fds, queues, errp) < 0) {
- return false;
+ if (tap->vhostfd || tap->vhostfds) {
+ if (net_parse_fds(tap->vhostfd ?: tap->vhostfds,
+ vhost_fds, queues, errp) < 0) {
+ return false;
+ }
+ } else {
+ *vhost_fds = g_new(int, queues);
+ for (int i = 0; i < queues; i++) {
+ int vhostfd = open("/dev/vhost-net", O_RDWR);
+ if (vhostfd < 0) {
+ error_setg_file_open(errp, errno, "/dev/vhost-net");
+ net_free_fds(*vhost_fds, i);
+ return false;
+ }
+ (*vhost_fds)[i] = vhostfd;
+ }
}
if (!unblock_fds(*vhost_fds, queues, errp)) {
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 05/15] net/tap: move vhost initialization to tap_setup_vhost()
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (3 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 04/15] net/tap: move vhost-net open() calls to tap_parse_vhost_fds() Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 06/15] net/tap: use container_of instead of DO_UPCAST Vladimir Sementsov-Ogievskiy
` (11 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
Make a new helper function in a way it can be reused later for
TAP fd-migration feature: we'll need to initialize vhost in a later
point when we doesn't have access to QAPI parameters.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Ben Chaney <bchaney@akamai.com>
---
net/tap.c | 62 ++++++++++++++++++++++++++++++++++---------------------
1 file changed, 38 insertions(+), 24 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index dcc914ffdf2..3a0a7a9f2ab 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -71,6 +71,8 @@ static const int kernel_feature_bits[] = {
typedef struct TAPState {
NetClientState nc;
int fd;
+ int vhostfd;
+ uint32_t vhost_busyloop_timeout;
char down_script[1024];
char down_script_arg[128];
uint8_t buf[NET_BUFSIZE];
@@ -723,6 +725,38 @@ static int net_tap_init(const NetdevTapOptions *tap, int *vnet_hdr,
return fd;
}
+static bool tap_setup_vhost(TAPState *s, Error **errp)
+{
+ VhostNetOptions options;
+
+ if (s->vhostfd == -1) {
+ return true;
+ }
+
+ options.backend_type = VHOST_BACKEND_TYPE_KERNEL;
+ options.net_backend = &s->nc;
+ options.busyloop_timeout = s->vhost_busyloop_timeout;
+ options.opaque = (void *)(uintptr_t)s->vhostfd;
+ options.nvqs = 2;
+ options.feature_bits = kernel_feature_bits;
+ options.get_acked_features = NULL;
+ options.save_acked_features = NULL;
+ options.max_tx_queue_size = 0;
+ options.is_vhost_user = false;
+
+ s->vhost_net = vhost_net_init(&options);
+ if (!s->vhost_net) {
+ error_setg(errp,
+ "vhost-net requested but could not be initialized");
+ return false;
+ }
+
+ /* vhostfd ownership is passed to s->vhost_net */
+ s->vhostfd = -1;
+
+ return true;
+}
+
static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
const char *name,
const char *ifname, const char *script,
@@ -757,30 +791,10 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
}
}
- if (vhostfd != -1) {
- VhostNetOptions options;
-
- options.backend_type = VHOST_BACKEND_TYPE_KERNEL;
- options.net_backend = &s->nc;
- if (tap->has_poll_us) {
- options.busyloop_timeout = tap->poll_us;
- } else {
- options.busyloop_timeout = 0;
- }
- options.opaque = (void *)(uintptr_t)vhostfd;
- options.nvqs = 2;
- options.feature_bits = kernel_feature_bits;
- options.get_acked_features = NULL;
- options.save_acked_features = NULL;
- options.max_tx_queue_size = 0;
- options.is_vhost_user = false;
-
- s->vhost_net = vhost_net_init(&options);
- if (!s->vhost_net) {
- error_setg(errp,
- "vhost-net requested but could not be initialized");
- goto failed;
- }
+ s->vhostfd = vhostfd;
+ s->vhost_busyloop_timeout = tap->has_poll_us ? tap->poll_us : 0;
+ if (!tap_setup_vhost(s, errp)) {
+ return false;
}
return true;
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 06/15] net/tap: use container_of instead of DO_UPCAST
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (4 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 05/15] net/tap: move vhost initialization to tap_setup_vhost() Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 07/15] net/tap: QOMify tap backend Vladimir Sementsov-Ogievskiy
` (10 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
We are going to QOMify tap backend, which includes deriving TAPState
from Object. So "NetClientState nc" will not be a first member.
Let's parepare for this change, and use container_of(), which will
work regardless position of "nc" field.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
net/tap.c | 36 ++++++++++++++++++------------------
1 file changed, 18 insertions(+), 18 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index 3a0a7a9f2ab..0679580fcaf 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -176,7 +176,7 @@ static ssize_t tap_write_packet(TAPState *s, const struct iovec *iov, int iovcnt
static ssize_t tap_receive_iov(NetClientState *nc, const struct iovec *iov,
int iovcnt)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
const struct iovec *iovp = iov;
g_autofree struct iovec *iov_copy = NULL;
struct virtio_net_hdr hdr = { };
@@ -212,7 +212,7 @@ ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen)
static void tap_send_completed(NetClientState *nc, ssize_t len)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
tap_read_poll(s, true);
}
@@ -272,7 +272,7 @@ static void tap_send(void *opaque)
static bool tap_has_ufo(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
@@ -281,7 +281,7 @@ static bool tap_has_ufo(NetClientState *nc)
static bool tap_has_uso(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
@@ -290,7 +290,7 @@ static bool tap_has_uso(NetClientState *nc)
static bool tap_has_tunnel(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
return s->has_tunnel;
@@ -298,7 +298,7 @@ static bool tap_has_tunnel(NetClientState *nc)
static bool tap_has_vnet_hdr(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
@@ -312,7 +312,7 @@ static bool tap_has_vnet_hdr_len(NetClientState *nc, int len)
static void tap_set_vnet_hdr_len(NetClientState *nc, int len)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
@@ -323,21 +323,21 @@ static void tap_set_vnet_hdr_len(NetClientState *nc, int len)
static int tap_set_vnet_le(NetClientState *nc, bool is_le)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
return tap_fd_set_vnet_le(s->fd, is_le);
}
static int tap_set_vnet_be(NetClientState *nc, bool is_be)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
return tap_fd_set_vnet_be(s->fd, is_be);
}
static void tap_set_offload(NetClientState *nc, const NetOffloads *ol)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
if (s->fd < 0) {
return;
}
@@ -358,7 +358,7 @@ static void tap_exit_notify(Notifier *notifier, void *data)
static void tap_cleanup(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
if (s->vhost_net) {
vhost_net_cleanup(s->vhost_net);
@@ -382,14 +382,14 @@ static void tap_cleanup(NetClientState *nc)
static void tap_poll(NetClientState *nc, bool enable)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
tap_read_poll(s, enable);
tap_write_poll(s, enable);
}
static bool tap_set_steering_ebpf(NetClientState *nc, int prog_fd)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
return tap_fd_set_steering_ebpf(s->fd, prog_fd) == 0;
@@ -397,7 +397,7 @@ static bool tap_set_steering_ebpf(NetClientState *nc, int prog_fd)
int tap_get_fd(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
return s->fd;
}
@@ -409,7 +409,7 @@ int tap_get_fd(NetClientState *nc)
*/
static VHostNetState *tap_get_vhost_net(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
return s->vhost_net;
}
@@ -448,7 +448,7 @@ static TAPState *net_tap_fd_init(NetClientState *peer,
nc = qemu_new_net_client(&net_tap_info, peer, model, name);
- s = DO_UPCAST(TAPState, nc, nc);
+ s = container_of(nc, TAPState, nc);
s->fd = fd;
s->host_vnet_hdr_len = vnet_hdr ? sizeof(struct virtio_net_hdr) : 0;
@@ -1017,7 +1017,7 @@ fail:
int tap_enable(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
int ret;
if (s->enabled) {
@@ -1034,7 +1034,7 @@ int tap_enable(NetClientState *nc)
int tap_disable(NetClientState *nc)
{
- TAPState *s = DO_UPCAST(TAPState, nc, nc);
+ TAPState *s = container_of(nc, TAPState, nc);
int ret;
if (s->enabled == 0) {
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 07/15] net/tap: QOMify tap backend
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (5 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 06/15] net/tap: use container_of instead of DO_UPCAST Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 08/15] net/tap: add TYPE_VMSTATE_IF interface Vladimir Sementsov-Ogievskiy
` (9 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
We prepare for being able to migrate TAP backend. We'll need a
user change-able property for it, which can be set from machine
type. So, let's QOMify it first.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
include/net/net.h | 7 +++++++
include/net/tap.h | 2 ++
net/net.c | 14 +++++++-------
net/tap.c | 48 +++++++++++++++++++++++++++++++++++++++--------
4 files changed, 56 insertions(+), 15 deletions(-)
diff --git a/include/net/net.h b/include/net/net.h
index 45bc86fc86b..bdf16bb3e64 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -160,6 +160,13 @@ char *qemu_mac_strdup_printf(const uint8_t *macaddr);
NetClientState *qemu_find_netdev(const char *id);
int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
NetClientDriver type, int max);
+void qemu_net_client_setup(NetClientState *nc,
+ NetClientInfo *info,
+ NetClientState *peer,
+ const char *model,
+ const char *name,
+ NetClientDestructor *destructor,
+ bool is_datapath);
NetClientState *qemu_new_net_client(NetClientInfo *info,
NetClientState *peer,
const char *model,
diff --git a/include/net/tap.h b/include/net/tap.h
index 6f34f13eae4..268570571f4 100644
--- a/include/net/tap.h
+++ b/include/net/tap.h
@@ -28,6 +28,8 @@
#include "standard-headers/linux/virtio_net.h"
+#define TYPE_TAP_NETDEV "tap-netdev"
+
int tap_enable(NetClientState *nc);
int tap_disable(NetClientState *nc);
diff --git a/net/net.c b/net/net.c
index 2892f1730d1..a06558b75bf 100644
--- a/net/net.c
+++ b/net/net.c
@@ -261,13 +261,13 @@ static ssize_t qemu_deliver_packet_iov(NetClientState *sender,
int iovcnt,
void *opaque);
-static void qemu_net_client_setup(NetClientState *nc,
- NetClientInfo *info,
- NetClientState *peer,
- const char *model,
- const char *name,
- NetClientDestructor *destructor,
- bool is_datapath)
+void qemu_net_client_setup(NetClientState *nc,
+ NetClientInfo *info,
+ NetClientState *peer,
+ const char *model,
+ const char *name,
+ NetClientDestructor *destructor,
+ bool is_datapath)
{
nc->info = info;
nc->model = g_strdup(model);
diff --git a/net/tap.c b/net/tap.c
index 0679580fcaf..8ba48180b01 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -43,6 +43,7 @@
#include "qemu/main-loop.h"
#include "qemu/sockets.h"
#include "hw/virtio/vhost.h"
+#include "qom/object.h"
#include "net/tap.h"
#include "net/util.h"
@@ -68,7 +69,11 @@ static const int kernel_feature_bits[] = {
VHOST_INVALID_FEATURE_BIT
};
-typedef struct TAPState {
+OBJECT_DECLARE_SIMPLE_TYPE(TAPState, TAP_NETDEV)
+
+struct TAPState {
+ Object parent_obj;
+
NetClientState nc;
int fd;
int vhostfd;
@@ -86,7 +91,7 @@ typedef struct TAPState {
VHostNetState *vhost_net;
unsigned host_vnet_hdr_len;
Notifier exit;
-} TAPState;
+};
static void launch_script(const char *setup_script, const char *ifname,
int fd, Error **errp);
@@ -414,6 +419,19 @@ static VHostNetState *tap_get_vhost_net(NetClientState *nc)
return s->vhost_net;
}
+
+static const TypeInfo tap_netdev_info = {
+ .name = TYPE_TAP_NETDEV,
+ .parent = TYPE_OBJECT,
+ .instance_size = sizeof(TAPState),
+};
+
+static void tap_net_client_destructor(NetClientState *nc)
+{
+ TAPState *s = container_of(nc, TAPState, nc);
+ object_unref(OBJECT(s));
+}
+
/* fd support */
static NetClientInfo net_tap_info = {
@@ -436,6 +454,18 @@ static NetClientInfo net_tap_info = {
.get_vhost_net = tap_get_vhost_net,
};
+static TAPState *new_tap(NetClientState *peer,
+ const char *model,
+ const char *name)
+{
+ TAPState *s = TAP_NETDEV(object_new(TYPE_TAP_NETDEV));
+
+ qemu_net_client_setup(&s->nc, &net_tap_info, peer, model, name,
+ tap_net_client_destructor, true);
+
+ return s;
+}
+
static TAPState *net_tap_fd_init(NetClientState *peer,
const char *model,
const char *name,
@@ -443,12 +473,7 @@ static TAPState *net_tap_fd_init(NetClientState *peer,
int vnet_hdr)
{
NetOffloads ol = {};
- NetClientState *nc;
- TAPState *s;
-
- nc = qemu_new_net_client(&net_tap_info, peer, model, name);
-
- s = container_of(nc, TAPState, nc);
+ TAPState *s = new_tap(peer, model, name);
s->fd = fd;
s->host_vnet_hdr_len = vnet_hdr ? sizeof(struct virtio_net_hdr) : 0;
@@ -1049,3 +1074,10 @@ int tap_disable(NetClientState *nc)
return ret;
}
}
+
+static void tap_register_types(void)
+{
+ type_register_static(&tap_netdev_info);
+}
+
+type_init(tap_register_types)
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 08/15] net/tap: add TYPE_VMSTATE_IF interface
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (6 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 07/15] net/tap: QOMify tap backend Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 09/15] qapi: add local migration parameter Vladimir Sementsov-Ogievskiy
` (8 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
We'll need it to implement TAP backend live migration.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
net/tap.c | 43 ++++++++++++++++++++++++++++++++++---------
1 file changed, 34 insertions(+), 9 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index 8ba48180b01..95bcfaaf1ea 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -43,7 +43,6 @@
#include "qemu/main-loop.h"
#include "qemu/sockets.h"
#include "hw/virtio/vhost.h"
-#include "qom/object.h"
#include "net/tap.h"
#include "net/util.h"
@@ -91,6 +90,8 @@ struct TAPState {
VHostNetState *vhost_net;
unsigned host_vnet_hdr_len;
Notifier exit;
+
+ int queue_index;
};
static void launch_script(const char *setup_script, const char *ifname,
@@ -420,10 +421,29 @@ static VHostNetState *tap_get_vhost_net(NetClientState *nc)
}
+static char *tap_vmstate_if_get_id(VMStateIf *obj)
+{
+ TAPState *s = TAP_NETDEV(obj);
+ char *res = g_strdup_printf("%s/%d", s->nc.name, s->queue_index);
+ return res;
+}
+
+static void tap_class_init(ObjectClass *klass, const void *data)
+{
+ VMStateIfClass *vc = VMSTATE_IF_CLASS(klass);
+
+ vc->get_id = tap_vmstate_if_get_id;
+}
+
static const TypeInfo tap_netdev_info = {
.name = TYPE_TAP_NETDEV,
.parent = TYPE_OBJECT,
.instance_size = sizeof(TAPState),
+ .class_init = tap_class_init,
+ .interfaces = (const InterfaceInfo[]) {
+ { TYPE_VMSTATE_IF },
+ { }
+ },
};
static void tap_net_client_destructor(NetClientState *nc)
@@ -456,13 +476,16 @@ static NetClientInfo net_tap_info = {
static TAPState *new_tap(NetClientState *peer,
const char *model,
- const char *name)
+ const char *name,
+ int queue_index)
{
TAPState *s = TAP_NETDEV(object_new(TYPE_TAP_NETDEV));
qemu_net_client_setup(&s->nc, &net_tap_info, peer, model, name,
tap_net_client_destructor, true);
+ s->queue_index = queue_index;
+
return s;
}
@@ -470,10 +493,11 @@ static TAPState *net_tap_fd_init(NetClientState *peer,
const char *model,
const char *name,
int fd,
- int vnet_hdr)
+ int vnet_hdr,
+ int queue_index)
{
NetOffloads ol = {};
- TAPState *s = new_tap(peer, model, name);
+ TAPState *s = new_tap(peer, model, name, queue_index);
s->fd = fd;
s->host_vnet_hdr_len = vnet_hdr ? sizeof(struct virtio_net_hdr) : 0;
@@ -710,7 +734,7 @@ int net_init_bridge(const Netdev *netdev, const char *name,
close(fd);
return -1;
}
- s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
+ s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr, 0);
qemu_set_info_str(&s->nc, "helper=%s,br=%s", helper, br);
@@ -786,10 +810,11 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
const char *name,
const char *ifname, const char *script,
const char *downscript, int vhostfd,
- int vnet_hdr, int fd, Error **errp)
+ int vnet_hdr, int fd, int queue_index,
+ Error **errp)
{
TAPState *s = net_tap_fd_init(peer, tap->helper ? "bridge" : "tap",
- name, fd, vnet_hdr);
+ name, fd, vnet_hdr, queue_index);
bool sndbuf_required = tap->has_sndbuf;
int sndbuf =
(tap->has_sndbuf && tap->sndbuf) ? MIN(tap->sndbuf, INT_MAX) : INT_MAX;
@@ -990,7 +1015,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
if (!net_init_tap_one(tap, peer, name, ifname,
NULL, NULL,
vhost_fds ? vhost_fds[i] : -1,
- vnet_hdr, fds[i], errp)) {
+ vnet_hdr, fds[i], i, errp)) {
goto fail;
}
}
@@ -1025,7 +1050,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
i >= 1 ? NULL : script,
i >= 1 ? NULL : downscript,
vhost_fds ? vhost_fds[i] : -1,
- vnet_hdr, fd, errp)) {
+ vnet_hdr, fd, i, errp)) {
goto fail;
}
}
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 09/15] qapi: add local migration parameter
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (7 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 08/15] net/tap: add TYPE_VMSTATE_IF interface Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 10/15] migration/channel: check that transfer is UNIX socket when "local" set Vladimir Sementsov-Ogievskiy
` (7 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Eric Blake
We are going to implement local-migration feature: some devices will be
able to transfer open file descriptors through migration stream (which
must UNIX domain socket for that purpose). This allows to transfer the
whole backend state without reconnecting and restarting the backend
service. For example, virtio-net will migrate its attached TAP netdev,
together with its connected file descriptors.
In this commit we introduce a migration parameter, which enables
the feature for devices that support it (none at the moment).
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Acked-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Peter Xu <peterx@redhat.com>
Reviewed-by: Ben Chaney <bchaney@akamai.com>
---
include/migration/misc.h | 2 ++
migration/options.c | 18 +++++++++++++++++-
qapi/migration.json | 15 +++++++++++++--
3 files changed, 32 insertions(+), 3 deletions(-)
diff --git a/include/migration/misc.h b/include/migration/misc.h
index 2b2fbb59a40..019717f4cda 100644
--- a/include/migration/misc.h
+++ b/include/migration/misc.h
@@ -161,4 +161,6 @@ bool multifd_join_device_state_save_threads(void);
void migration_request_switchover_ack_legacy(const char *requester);
+bool migrate_local(void);
+
#endif
diff --git a/migration/options.c b/migration/options.c
index dfce19405d4..5c439f6d724 100644
--- a/migration/options.c
+++ b/migration/options.c
@@ -14,6 +14,7 @@
#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qemu/units.h"
+#include "qapi/util.h"
#include "exec/target_page.h"
#include "qapi/clone-visitor.h"
#include "qapi/error.h"
@@ -25,6 +26,7 @@
#include "migration/colo.h"
#include "migration/cpr.h"
#include "migration/misc.h"
+#include "migration/options.h"
#include "migration.h"
#include "migration-stats.h"
#include "qemu-file.h"
@@ -350,6 +352,12 @@ bool migrate_mapped_ram(void)
return s->capabilities[MIGRATION_CAPABILITY_MAPPED_RAM];
}
+bool migrate_local(void)
+{
+ MigrationState *s = migrate_get_current();
+ return s->parameters.local;
+}
+
bool migrate_ignore_shared(void)
{
MigrationState *s = migrate_get_current();
@@ -1085,7 +1093,7 @@ static void migrate_mark_all_params_present(MigrationParameters *p)
&p->has_announce_step, &p->has_block_bitmap_mapping,
&p->has_x_vcpu_dirty_limit_period, &p->has_vcpu_dirty_limit,
&p->has_mode, &p->has_zero_page_detection, &p->has_direct_io,
- &p->has_x_rdma_chunk_size, &p->has_cpr_exec_command,
+ &p->has_x_rdma_chunk_size, &p->has_cpr_exec_command, &p->has_local,
};
len = ARRAY_SIZE(has_fields);
@@ -1433,6 +1441,10 @@ static void migrate_params_test_apply(MigrationParameters *params,
qapi_free_strList(dest->cpr_exec_command);
dest->cpr_exec_command = QAPI_CLONE(strList, params->cpr_exec_command);
}
+
+ if (params->has_local) {
+ dest->local = params->local;
+ }
}
static void migrate_params_apply(MigrationParameters *params)
@@ -1565,6 +1577,10 @@ static void migrate_params_apply(MigrationParameters *params)
s->parameters.cpr_exec_command =
QAPI_CLONE(strList, params->cpr_exec_command);
}
+
+ if (params->has_local) {
+ s->parameters.local = params->local;
+ }
}
void qmp_migrate_set_parameters(MigrationParameters *params, Error **errp)
diff --git a/qapi/migration.json b/qapi/migration.json
index 66bd900465a..813c1f76e46 100644
--- a/qapi/migration.json
+++ b/qapi/migration.json
@@ -830,7 +830,8 @@
'zero-page-detection',
'direct-io',
{ 'name': 'x-rdma-chunk-size', 'features': [ 'unstable' ] },
- 'cpr-exec-command'] }
+ 'cpr-exec-command',
+ 'local'] }
##
# @migrate-set-parameters:
@@ -1012,6 +1013,15 @@
# Must be set to the same value on both source and destination
# before migration starts. (Since 11.1)
#
+# @local: Permit the use of optimizations for local migration.
+# This must only be set when both the source and destination
+# QEMU processes are on the same OS and directly connected
+# with a UNIX domain socket as the migration channel to enable
+# use of file descriptor passing. Individual device backends
+# may need additional configuration flags set to enable local
+# migration optimizations. This will be documented against the
+# device backends where it applies. (Since 11.2)
+#
# Features:
#
# @unstable: Members @x-checkpoint-delay, @x-rdma-chunk-size, and
@@ -1053,7 +1063,8 @@
'*direct-io': 'bool',
'*x-rdma-chunk-size': { 'type': 'uint64',
'features': [ 'unstable' ] },
- '*cpr-exec-command': [ 'str' ]} }
+ '*cpr-exec-command': [ 'str' ],
+ '*local': 'bool' } }
##
# @query-migrate-parameters:
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 10/15] migration/channel: check that transfer is UNIX socket when "local" set
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (8 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 09/15] qapi: add local migration parameter Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 11/15] virtio-net: support local migration of backend Vladimir Sementsov-Ogievskiy
` (6 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland
As documented, for "local", the migration channel must be direct
UNIX socket connection from source to target. We can't check for
it being "direct", but let's at least check that we deal with
UNIX socket (fd-passing supported).
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
migration/channel.c | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/migration/channel.c b/migration/channel.c
index 1e2935f926b..ba00dd1931d 100644
--- a/migration/channel.c
+++ b/migration/channel.c
@@ -214,6 +214,13 @@ void migration_channel_process_incoming(QIOChannel *ioc)
trace_migration_set_incoming_channel(
ioc, object_get_typename(OBJECT(ioc)));
+ if (migrate_local() &&
+ !qio_channel_has_feature(ioc, QIO_CHANNEL_FEATURE_FD_PASS)) {
+ error_setg(&local_err,
+ "local migration requires a UNIX domain socket channel");
+ goto out;
+ }
+
if (migrate_channel_requires_tls_upgrade(ioc)) {
migration_tls_channel_process_incoming(ioc, &local_err);
} else {
@@ -241,6 +248,16 @@ void migration_channel_connect_outgoing(MigrationState *s, QIOChannel *ioc)
{
trace_migration_set_outgoing_channel(ioc, object_get_typename(OBJECT(ioc)));
+ if (migrate_local() &&
+ !qio_channel_has_feature(ioc, QIO_CHANNEL_FEATURE_FD_PASS)) {
+ Error *local_err = NULL;
+
+ error_setg(&local_err,
+ "local migration requires a UNIX domain socket channel");
+ migration_connect_error_propagate(s, local_err);
+ return;
+ }
+
if (migrate_channel_requires_tls_upgrade(ioc)) {
Error *local_err = NULL;
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 11/15] virtio-net: support local migration of backend
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (9 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 10/15] migration/channel: check that transfer is UNIX socket when "local" set Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 12/15] net/tap: disable read polling for stopped VM Vladimir Sementsov-Ogievskiy
` (5 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
Next commit will introduce live-migration (with fd-passing) for
TAP net backend. So, now we prepare virtio-net for it
Add virtio-net option local-migration, which is true by default,
but false for older machine types, which doesn't support the feature.
We introduce interface for live-migrating backends:
1. ->is_wait_incoming() handler, so that virtio-net knows, that
backend is not fully intialized, as it waits for incoming migration
stream.
2. MIG_PRI_BACKEND priority: backends should migrate with higher
priority than virtio-net, so that we can do final preparations
here in post-load handlers and be sure, that backends are already
prepared.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
hw/net/virtio-net.c | 89 +++++++++++++++++++++++++++++++++-
include/hw/virtio/virtio-net.h | 1 +
include/migration/vmstate.h | 2 +
include/net/net.h | 2 +
4 files changed, 93 insertions(+), 1 deletion(-)
diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index f0e3beb2903..c6e7f7a370f 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -40,6 +40,7 @@
#include "migration/misc.h"
#include "standard-headers/linux/ethtool.h"
#include "system/system.h"
+#include "system/runstate.h"
#include "system/replay.h"
#include "trace.h"
#include "monitor/qdev.h"
@@ -3060,7 +3061,17 @@ static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
n->multiqueue = multiqueue;
virtio_net_change_num_queues(n, max * 2 + 1);
- virtio_net_set_queue_pairs(n);
+ /*
+ * virtio_net_set_multiqueue() called from set_features(0) on early
+ * reset, when peer may wait for incoming (and is not initialized
+ * yet).
+ * Don't worry about it: virtio_net_set_queue_pairs() will be called
+ * later from virtio_net_post_load_device(), and anyway will be
+ * no-op for local incoming migration with live backend passing.
+ */
+ if (!n->peers_wait_incoming) {
+ virtio_net_set_queue_pairs(n);
+ }
}
static int virtio_net_pre_load_queues(VirtIODevice *vdev, uint32_t n)
@@ -3089,6 +3100,17 @@ static void virtio_net_get_features(VirtIODevice *vdev, uint64_t *features,
virtio_add_feature_ex(features, VIRTIO_NET_F_MAC);
+ if (n->peers_wait_incoming) {
+ /*
+ * Excessive feature set is OK for early initialization when
+ * we wait for local incoming migration: actual guest-negotiated
+ * features will come with migration stream anyway. And we are sure
+ * that we support same host-features as source, because the backend
+ * is the same (the same TAP device, for example).
+ */
+ return;
+ }
+
if (!peer_has_vnet_hdr(n)) {
virtio_clear_feature_ex(features, VIRTIO_NET_F_CSUM);
virtio_clear_feature_ex(features, VIRTIO_NET_F_HOST_TSO4);
@@ -3185,6 +3207,7 @@ static int virtio_net_post_load_device(void *opaque, int version_id)
VirtIODevice *vdev = VIRTIO_DEVICE(n);
int i, link_down;
bool has_tunnel_hdr = virtio_has_tunnel_hdr(vdev->guest_features_ex);
+ Error *local_err = NULL;
trace_virtio_net_post_load_device();
virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
@@ -3242,6 +3265,20 @@ static int virtio_net_post_load_device(void *opaque, int version_id)
}
virtio_net_commit_rss_config(n);
+
+ /*
+ * If live-migration is enabled for some backend, than backend
+ * has already been migrated at higher priority (MIG_PRI_BACKEND)
+ * and virtio_net_vnet_post_load() has already called
+ * peer_test_vnet_hdr(). Recompute host_features so that virtio-net
+ * reflects the capabilities of the restored backend.
+ */
+ virtio_net_get_features(vdev, &vdev->host_features, &local_err);
+ if (local_err) {
+ error_report_err(local_err);
+ return -EINVAL;
+ }
+
return 0;
}
@@ -3392,6 +3429,14 @@ static int virtio_net_vnet_post_load(void *opaque, int version_id)
{
struct VirtIONetMigTmp *tmp = opaque;
+ /*
+ * If live-migration is enabled for some backend, than backend
+ * has already been migrated at higher priority (MIG_PRI_BACKEND),
+ * so n->has_vnet_hdr can be refreshed from the live backend right
+ * here.
+ */
+ peer_test_vnet_hdr(tmp->parent);
+
if (tmp->has_vnet_hdr && !peer_has_vnet_hdr(tmp->parent)) {
error_report("virtio-net: saved image requires vnet_hdr=on");
return -EINVAL;
@@ -3871,6 +3916,42 @@ static bool failover_hide_primary_device(DeviceListener *listener,
return qatomic_read(&n->failover_primary_hidden);
}
+static bool virtio_net_check_peers_wait_incoming(VirtIONet *n, bool *waiting,
+ Error **errp)
+{
+ bool has_waiting = false;
+ bool has_not_waiting = false;
+
+ for (int i = 0; i < n->max_queue_pairs; i++) {
+ NetClientState *peer = n->nic->ncs[i].peer;
+ if (!peer) {
+ continue;
+ }
+
+ if (peer->info->is_wait_incoming &&
+ peer->info->is_wait_incoming(peer)) {
+ has_waiting = true;
+ } else {
+ has_not_waiting = true;
+ }
+
+ if (has_waiting && has_not_waiting) {
+ error_setg(errp, "Mixed peer states: some peers wait for incoming "
+ "migration while others don't");
+ return false;
+ }
+ }
+
+ if (has_waiting && !runstate_check(RUN_STATE_INMIGRATE)) {
+ error_setg(errp, "Peers wait for incoming, but it's not an incoming "
+ "migration.");
+ return false;
+ }
+
+ *waiting = has_waiting;
+ return true;
+}
+
static void virtio_net_device_realize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
@@ -4008,6 +4089,12 @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
n->nic->ncs[i].do_not_pad = true;
}
+ if (!virtio_net_check_peers_wait_incoming(n, &n->peers_wait_incoming,
+ errp)) {
+ virtio_cleanup(vdev);
+ return;
+ }
+
peer_test_vnet_hdr(n);
if (peer_has_vnet_hdr(n)) {
n->host_hdr_len = sizeof(struct virtio_net_hdr);
diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h
index 371e3764282..8c967760c2a 100644
--- a/include/hw/virtio/virtio-net.h
+++ b/include/hw/virtio/virtio-net.h
@@ -230,6 +230,7 @@ struct VirtIONet {
struct EBPFRSSContext ebpf_rss;
uint32_t nr_ebpf_rss_fds;
char **ebpf_rss_fds;
+ bool peers_wait_incoming;
};
size_t virtio_net_handle_ctrl_iov(VirtIODevice *vdev,
diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
index 1b7f295417e..bbc569adc52 100644
--- a/include/migration/vmstate.h
+++ b/include/migration/vmstate.h
@@ -178,6 +178,8 @@ typedef enum {
MIG_PRI_LOW, /* Must happen after default */
MIG_PRI_DEFAULT,
+ MIG_PRI_BACKEND, /* Must happen before emulated devices, */
+ /* e.g. virtio-net */
MIG_PRI_IOMMU, /* Must happen before PCI devices */
MIG_PRI_PCI_BUS, /* Must happen before IOMMU */
MIG_PRI_VIRTIO_MEM, /* Must happen before IOMMU */
diff --git a/include/net/net.h b/include/net/net.h
index bdf16bb3e64..658b0d0aaf1 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -81,6 +81,7 @@ typedef void (SocketReadStateFinalize)(SocketReadState *rs);
typedef void (NetAnnounce)(NetClientState *);
typedef bool (SetSteeringEBPF)(NetClientState *, int);
typedef bool (NetCheckPeerType)(NetClientState *, ObjectClass *, Error **);
+typedef bool (IsWaitIncoming)(NetClientState *);
typedef struct vhost_net *(GetVHostNet)(NetClientState *nc);
typedef struct NetClientInfo {
@@ -109,6 +110,7 @@ typedef struct NetClientInfo {
NetAnnounce *announce;
SetSteeringEBPF *set_steering_ebpf;
NetCheckPeerType *check_peer_type;
+ IsWaitIncoming *is_wait_incoming;
GetVHostNet *get_vhost_net;
} NetClientInfo;
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 12/15] net/tap: disable read polling for stopped VM
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (10 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 11/15] virtio-net: support local migration of backend Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-15 14:51 ` Chaney, Ben
2026-07-14 15:42 ` [PATCH v19 13/15] net/tap: support local migration with virtio-net Vladimir Sementsov-Ogievskiy
` (4 subsequent siblings)
16 siblings, 1 reply; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang
Polling when VM is stopped doesn't make real sense, as stopped VM can't
handle incoming traffic anyway.
And it's critical for introduction of local TAP migration
feature in the next commit: the TAP device will be transferred
to the target (open fd will be passed through migration channel),
and if we continue polling on source, we may get a package, which
we'll never handle on source (already stopped), it will be lost.
Better is save this package for target VM to handle.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
net/tap.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/net/tap.c b/net/tap.c
index 95bcfaaf1ea..2bd4b089573 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -36,6 +36,7 @@
#include "net/net.h"
#include "clients.h"
#include "monitor/monitor.h"
+#include "system/runstate.h"
#include "system/system.h"
#include "qapi/error.h"
#include "qemu/cutils.h"
@@ -92,6 +93,8 @@ struct TAPState {
Notifier exit;
int queue_index;
+ bool read_poll_detached;
+ VMChangeStateEntry *vmstate;
};
static void launch_script(const char *setup_script, const char *ifname,
@@ -150,6 +153,23 @@ static void tap_read_poll(TAPState *s, bool enable)
tap_update_fd_handler(s);
}
+static void tap_vm_state_change(void *opaque, bool running, RunState state)
+{
+ TAPState *s = opaque;
+
+ if (running) {
+ if (s->read_poll_detached) {
+ tap_read_poll(s, true);
+ s->read_poll_detached = false;
+ }
+ } else if (state == RUN_STATE_FINISH_MIGRATE) {
+ if (s->read_poll) {
+ s->read_poll_detached = true;
+ tap_read_poll(s, false);
+ }
+ }
+}
+
static void tap_write_poll(TAPState *s, bool enable)
{
s->write_poll = enable;
@@ -380,6 +400,11 @@ static void tap_cleanup(NetClientState *nc)
s->exit.notify = NULL;
}
+ if (s->vmstate) {
+ qemu_del_vm_change_state_handler(s->vmstate);
+ s->vmstate = NULL;
+ }
+
tap_read_poll(s, false);
tap_write_poll(s, false);
close(s->fd);
@@ -819,6 +844,9 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
int sndbuf =
(tap->has_sndbuf && tap->sndbuf) ? MIN(tap->sndbuf, INT_MAX) : INT_MAX;
+ s->read_poll_detached = false;
+ s->vmstate = qemu_add_vm_change_state_handler(tap_vm_state_change, s);
+
if (!tap_set_sndbuf(fd, sndbuf, sndbuf_required ? errp : NULL) &&
sndbuf_required) {
goto failed;
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH v19 12/15] net/tap: disable read polling for stopped VM
2026-07-14 15:42 ` [PATCH v19 12/15] net/tap: disable read polling for stopped VM Vladimir Sementsov-Ogievskiy
@ 2026-07-15 14:51 ` Chaney, Ben
0 siblings, 0 replies; 32+ messages in thread
From: Chaney, Ben @ 2026-07-15 14:51 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy, jasowang@redhat.com, mst@redhat.com
Cc: armbru@redhat.com, peterx@redhat.com, farosas@suse.de,
raphael.s.norwitz@gmail.com, qemu-devel@nongnu.org,
berrange@redhat.com, pbonzini@redhat.com, yc-core@yandex-team.ru,
mark.caveayland@nutanix.com, Jason Wang
On 7/14/26, 11:44 AM, "Vladimir Sementsov-Ogievskiy" <vsementsov@yandex-team.ru <mailto:vsementsov@yandex-team.ru>> wrote:
> +static void tap_vm_state_change(void *opaque, bool running, RunState state)
> +{
> + TAPState *s = opaque;
> +
> + if (running) {
> + if (s->read_poll_detached) {
> + tap_read_poll(s, true);
> + s->read_poll_detached = false;
> + }
> + } else if (state == RUN_STATE_FINISH_MIGRATE) {
> + if (s->read_poll) {
> + s->read_poll_detached = true;
> + tap_read_poll(s, false);
> + }
> + }
> +}
> +
tap_read_poll is called in a few other places. Is it necessary to update read_poll_detached there as well?
I'm not sure that it is, I'm trying to wrap my head around any possible ordering issues and it isn't obvious to me one way or the other.
Thanks,
Ben
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v19 13/15] net/tap: support local migration with virtio-net
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (11 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 12/15] net/tap: disable read polling for stopped VM Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-15 8:10 ` Vladimir Sementsov-Ogievskiy
2026-07-15 14:54 ` Chaney, Ben
2026-07-14 15:42 ` [PATCH v19 14/15] tests/functional: add skipWithoutSudo() decorator Vladimir Sementsov-Ogievskiy
` (3 subsequent siblings)
16 siblings, 2 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Jason Wang, Eric Blake
Support transferring of TAP state (including open fd).
Add new property "local-migration-supported", which defines
whether local-migration is actually supported for this TAP device.
Starting from 11.2 QEMU Machine Types it's enabled by default.
Note that local-migration (including migrating opened FDs
through migration channel, which must be UNIX socket) is
enabled by global "local" migration parameters. But individual
devices may have additional options to enable/disable it
per device.
The tricky thing is that we need to know whether to call open/connect in
TAP initialization code, i.e. we need to know the value of migration
parameter "local" when creating the TAP device. For incoming migration,
we can know only for TAP devices created with QMP after setting the
migration parameter with QMP.
So the full picture is:
On source, to start outgoing "local" migration you need:
- migration parameter "local" set to true
- "local-migration-supported" TAP option set to true (the
default, starting from 11.2 QEMU Machine Types)
If at least one of these options is not set, TAP backend
doesn't participate in migration.
On target, things are more difficult:
Same, you need both "local" and "local-migration-supported"
be set. And same, if one of them is not set, TAP backend
is initialized as usual, and doesn't accept any incoming
state.
Additionally, if you are going to set "local", it must be
set before creating the TAP device. If TAP device created
with "local" unset, it initializes as usual. If you enable
"local" after it and start incoming migration, it will fail
in .pre_load handler of TAP backend.
Moreover, there are interface restrictions: if you create TAP
device when QEMU is in INCOMING state, and both "local"
and "local-migration-supported" set, most of TAP options are
not allowed, and script/downscript are required to be explicitly
unset (set to "" or "no").
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
---
net/tap.c | 165 ++++++++++++++++++++++++++++++++++++++++++++++++--
qapi/net.json | 22 ++++++-
2 files changed, 180 insertions(+), 7 deletions(-)
diff --git a/net/tap.c b/net/tap.c
index 2bd4b089573..4162820bcee 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -38,12 +38,17 @@
#include "monitor/monitor.h"
#include "system/runstate.h"
#include "system/system.h"
+#include "migration/misc.h"
#include "qapi/error.h"
#include "qemu/cutils.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
#include "qemu/sockets.h"
#include "hw/virtio/vhost.h"
+#include "hw/core/vmstate-if.h"
+#include "migration/vmstate.h"
+#include "qom/object.h"
+#include "qom/compat-properties.h"
#include "net/tap.h"
#include "net/util.h"
@@ -71,6 +76,8 @@ static const int kernel_feature_bits[] = {
OBJECT_DECLARE_SIMPLE_TYPE(TAPState, TAP_NETDEV)
+static const VMStateDescription vmstate_tap;
+
struct TAPState {
Object parent_obj;
@@ -95,6 +102,7 @@ struct TAPState {
int queue_index;
bool read_poll_detached;
VMChangeStateEntry *vmstate;
+ bool local_migration_supported;
};
static void launch_script(const char *setup_script, const char *ifname,
@@ -409,6 +417,8 @@ static void tap_cleanup(NetClientState *nc)
tap_write_poll(s, false);
close(s->fd);
s->fd = -1;
+
+ vmstate_unregister(VMSTATE_IF(s), &vmstate_tap, s);
}
static void tap_poll(NetClientState *nc, bool enable)
@@ -445,6 +455,76 @@ static VHostNetState *tap_get_vhost_net(NetClientState *nc)
return s->vhost_net;
}
+static bool tap_is_wait_incoming(NetClientState *nc)
+{
+ TAPState *s = container_of(nc, TAPState, nc);
+ assert(nc->info->type == NET_CLIENT_DRIVER_TAP);
+ return s->fd == -1;
+}
+
+static bool tap_pre_load(void *opaque, Error **errp)
+{
+ TAPState *s = opaque;
+
+ if (s->fd != -1) {
+ error_setg(errp,
+ "TAP is already initialized and cannot receive "
+ "incoming fd. For local migration, 'local' "
+ "migration parameter must be set _before_ "
+ "creating TAP device.");
+ return false;
+ }
+
+ return true;
+}
+
+static bool tap_setup_vhost(TAPState *s, Error **errp);
+
+static bool tap_post_load(void *opaque, int version_id, Error **errp)
+{
+ ERRP_GUARD();
+ TAPState *s = opaque;
+
+ tap_read_poll(s, true);
+
+ if (s->fd < 0) {
+ error_setg(errp, "FD was not loaded during incoming migration");
+ return false;
+ }
+
+ if (!tap_setup_vhost(s, errp)) {
+ error_prepend(errp,
+ "Failed to setup vhost during TAP post-load: ");
+ return false;
+ }
+
+ return true;
+}
+
+static bool tap_needed(void *opaque)
+{
+ TAPState *s = opaque;
+
+ return s->local_migration_supported && migrate_local();
+}
+
+static const VMStateDescription vmstate_tap = {
+ .name = "net-tap",
+ .priority = MIG_PRI_BACKEND,
+ .pre_load_errp = tap_pre_load,
+ .post_load_errp = tap_post_load,
+ .needed = tap_needed,
+ .fields = (const VMStateField[]) {
+ VMSTATE_FD(fd, TAPState),
+ VMSTATE_BOOL(using_vnet_hdr, TAPState),
+ VMSTATE_BOOL(has_ufo, TAPState),
+ VMSTATE_BOOL(has_uso, TAPState),
+ VMSTATE_BOOL(has_tunnel, TAPState),
+ VMSTATE_BOOL(enabled, TAPState),
+ VMSTATE_UINT32(host_vnet_hdr_len, TAPState),
+ VMSTATE_END_OF_LIST()
+ }
+};
static char *tap_vmstate_if_get_id(VMStateIf *obj)
{
@@ -453,17 +533,42 @@ static char *tap_vmstate_if_get_id(VMStateIf *obj)
return res;
}
+static bool tap_get_local_migration_supported_prop(Object *obj, Error **errp)
+{
+ TAPState *s = TAP_NETDEV(obj);
+ return s->local_migration_supported;
+}
+
+static void tap_set_local_migration_supported_prop(Object *obj, bool value,
+ Error **errp)
+{
+ TAPState *s = TAP_NETDEV(obj);
+ s->local_migration_supported = value;
+}
+
+static void tap_instance_init(Object *obj)
+{
+ TAPState *s = TAP_NETDEV(obj);
+ s->local_migration_supported = false;
+}
+
static void tap_class_init(ObjectClass *klass, const void *data)
{
VMStateIfClass *vc = VMSTATE_IF_CLASS(klass);
vc->get_id = tap_vmstate_if_get_id;
+
+ object_class_property_add_bool(klass, "local-migration-supported",
+ tap_get_local_migration_supported_prop,
+ tap_set_local_migration_supported_prop);
}
static const TypeInfo tap_netdev_info = {
.name = TYPE_TAP_NETDEV,
.parent = TYPE_OBJECT,
.instance_size = sizeof(TAPState),
+ .instance_init = tap_instance_init,
+ .instance_post_init = object_apply_compat_props,
.class_init = tap_class_init,
.interfaces = (const InterfaceInfo[]) {
{ TYPE_VMSTATE_IF },
@@ -496,13 +601,16 @@ static NetClientInfo net_tap_info = {
.set_vnet_le = tap_set_vnet_le,
.set_vnet_be = tap_set_vnet_be,
.set_steering_ebpf = tap_set_steering_ebpf,
+ .is_wait_incoming = tap_is_wait_incoming,
.get_vhost_net = tap_get_vhost_net,
};
static TAPState *new_tap(NetClientState *peer,
const char *model,
const char *name,
- int queue_index)
+ int queue_index,
+ bool has_local_migration_supported,
+ bool local_migration_supported)
{
TAPState *s = TAP_NETDEV(object_new(TYPE_TAP_NETDEV));
@@ -511,6 +619,12 @@ static TAPState *new_tap(NetClientState *peer,
s->queue_index = queue_index;
+ if (has_local_migration_supported) {
+ s->local_migration_supported = local_migration_supported;
+ }
+
+ vmstate_register(VMSTATE_IF(s), VMSTATE_INSTANCE_ID_ANY, &vmstate_tap, s);
+
return s;
}
@@ -519,10 +633,14 @@ static TAPState *net_tap_fd_init(NetClientState *peer,
const char *name,
int fd,
int vnet_hdr,
- int queue_index)
+ int queue_index,
+ bool has_local_migration_supported,
+ bool local_migration_supported)
{
NetOffloads ol = {};
- TAPState *s = new_tap(peer, model, name, queue_index);
+ TAPState *s = new_tap(peer, model, name, queue_index,
+ has_local_migration_supported,
+ local_migration_supported);
s->fd = fd;
s->host_vnet_hdr_len = vnet_hdr ? sizeof(struct virtio_net_hdr) : 0;
@@ -759,7 +877,7 @@ int net_init_bridge(const Netdev *netdev, const char *name,
close(fd);
return -1;
}
- s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr, 0);
+ s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr, 0, true, false);
qemu_set_info_str(&s->nc, "helper=%s,br=%s", helper, br);
@@ -839,7 +957,9 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
Error **errp)
{
TAPState *s = net_tap_fd_init(peer, tap->helper ? "bridge" : "tap",
- name, fd, vnet_hdr, queue_index);
+ name, fd, vnet_hdr, queue_index,
+ tap->has_local_migration_supported,
+ tap->local_migration_supported);
bool sndbuf_required = tap->has_sndbuf;
int sndbuf =
(tap->has_sndbuf && tap->sndbuf) ? MIN(tap->sndbuf, INT_MAX) : INT_MAX;
@@ -987,6 +1107,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
/* for the no-fd, no-helper case */
char ifname[128];
int *fds = NULL, *vhost_fds = NULL;
+ bool incoming_fds;
assert(netdev->type == NET_CLIENT_DRIVER_TAP);
tap = &netdev->u.tap;
@@ -1009,6 +1130,23 @@ int net_init_tap(const Netdev *netdev, const char *name,
return -1;
}
+ incoming_fds = tap->local_migration_supported && migrate_local() &&
+ runstate_check(RUN_STATE_INMIGRATE);
+
+ if (incoming_fds &&
+ (tap->fd || tap->fds || tap->helper || tap->br || tap->ifname ||
+ tap->has_sndbuf || tap->has_vnet_hdr ||
+ !tap_is_explicit_no_script("script", tap->script) ||
+ !tap_is_explicit_no_script("downscript", tap->downscript))) {
+ error_setg(errp, "Local incoming migration of TAP device (-incoming, "
+ "migration parameter @local is set, "
+ "TAP parameter @local-migration-supported is set) "
+ "is incompatible with "
+ "fd=, fds=, helper=, br=, ifname=, sndbuf= and vnet_hdr=, "
+ "and requires explicit empty script= and downscript=");
+ return -1;
+ }
+
queues = tap_parse_fds_and_queues(tap, &fds, errp);
if (queues < 0) {
return -1;
@@ -1027,7 +1165,22 @@ int net_init_tap(const Netdev *netdev, const char *name,
goto fail;
}
- if (fds) {
+ if (incoming_fds) {
+ for (i = 0; i < queues; i++) {
+ TAPState *s = new_tap(peer, "tap", name, i,
+ tap->has_local_migration_supported,
+ tap->local_migration_supported);
+ qemu_set_info_str(&s->nc, "incoming");
+
+ s->fd = -1;
+ if (vhost_fds) {
+ s->vhostfd = vhost_fds[i];
+ s->vhost_busyloop_timeout = tap->has_poll_us ? tap->poll_us : 0;
+ } else {
+ s->vhostfd = -1;
+ }
+ }
+ } else if (fds) {
for (i = 0; i < queues; i++) {
if (i == 0) {
vnet_hdr = tap_probe_vnet_hdr(fds[i], errp);
diff --git a/qapi/net.json b/qapi/net.json
index ada0329ef9d..d0d6e303b0d 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -435,6 +435,25 @@
# @poll-us: maximum number of microseconds that could be spent on busy
# polling for tap (since 2.7)
#
+# @local-migration-supported: enable local migration for this TAP
+# backend. When set, local migration is enabled/disabled by
+# migration parameter @local for this TAP backend. When unset,
+# migration parameter @local is ignored for this TAP backend.
+# To be able to do incoming local migration of a TAP backend,
+# migration parameter @local must be set _before_ creating the
+# TAP backend. Otherwise, TAP backend is initialized as usual,
+# opening/creating TAP devices in kernel. In this case further
+# local incoming migration (with migration parameter @local set
+# after creating TAP backend with @local-migration-supporeted
+# parameter set) will simply fail.
+# Moreover, when QEMU is in incoming migration state, migration
+# parameter @local is set and @local-migration-supported is set,
+# the following options are not supported and must not be set:
+# @fd, @fds, @helper, @br, @ifname, @sndbuf, @vnet_hdr.
+# Additionally in this case @script and @downscipt must be
+# explicitly disabled (empty strings or "no").
+# (Since 11.2)
+#
# Since: 1.2
##
{ 'struct': 'NetdevTapOptions',
@@ -453,7 +472,8 @@
'*vhostfds': 'str',
'*vhostforce': 'bool',
'*queues': 'uint32',
- '*poll-us': 'uint32'} }
+ '*poll-us': 'uint32',
+ '*local-migration-supported': 'bool' } }
##
# @NetdevSocketOptions:
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH v19 13/15] net/tap: support local migration with virtio-net
2026-07-14 15:42 ` [PATCH v19 13/15] net/tap: support local migration with virtio-net Vladimir Sementsov-Ogievskiy
@ 2026-07-15 8:10 ` Vladimir Sementsov-Ogievskiy
2026-07-15 14:54 ` Chaney, Ben
1 sibling, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-15 8:10 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, qemu-devel,
berrange, pbonzini, yc-core, mark.caveayland, Jason Wang,
Eric Blake
On 14.07.26 18:42, Vladimir Sementsov-Ogievskiy wrote:
> Support transferring of TAP state (including open fd).
>
> Add new property "local-migration-supported", which defines
> whether local-migration is actually supported for this TAP device.
> Starting from 11.2 QEMU Machine Types it's enabled by default.
>
> Note that local-migration (including migrating opened FDs
> through migration channel, which must be UNIX socket) is
> enabled by global "local" migration parameters. But individual
> devices may have additional options to enable/disable it
> per device.
>
> The tricky thing is that we need to know whether to call open/connect in
> TAP initialization code, i.e. we need to know the value of migration
> parameter "local" when creating the TAP device. For incoming migration,
> we can know only for TAP devices created with QMP after setting the
> migration parameter with QMP.
>
> So the full picture is:
>
> On source, to start outgoing "local" migration you need:
>
> - migration parameter "local" set to true
> - "local-migration-supported" TAP option set to true (the
> default, starting from 11.2 QEMU Machine Types)
>
> If at least one of these options is not set, TAP backend
> doesn't participate in migration.
>
> On target, things are more difficult:
>
> Same, you need both "local" and "local-migration-supported"
> be set. And same, if one of them is not set, TAP backend
> is initialized as usual, and doesn't accept any incoming
> state.
>
> Additionally, if you are going to set "local", it must be
> set before creating the TAP device. If TAP device created
> with "local" unset, it initializes as usual. If you enable
> "local" after it and start incoming migration, it will fail
> in .pre_load handler of TAP backend.
>
> Moreover, there are interface restrictions: if you create TAP
> device when QEMU is in INCOMING state, and both "local"
> and "local-migration-supported" set, most of TAP options are
> not allowed, and script/downscript are required to be explicitly
> unset (set to "" or "no").
>
> Signed-off-by: Vladimir Sementsov-Ogievskiy<vsementsov@yandex-team.ru>
> ---
> net/tap.c | 165 ++++++++++++++++++++++++++++++++++++++++++++++++--
> qapi/net.json | 22 ++++++-
> 2 files changed, 180 insertions(+), 7 deletions(-)
squash in, to mark it unstable:
diff --git a/net/tap.c b/net/tap.c
index 4162820bcee..250ae15acb7 100644
--- a/net/tap.c
+++ b/net/tap.c
@@ -558,7 +558,7 @@ static void tap_class_init(ObjectClass *klass, const void *data)
vc->get_id = tap_vmstate_if_get_id;
- object_class_property_add_bool(klass, "local-migration-supported",
+ object_class_property_add_bool(klass, "x-local-migration-supported",
tap_get_local_migration_supported_prop,
tap_set_local_migration_supported_prop);
}
@@ -958,8 +958,8 @@ static bool net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
{
TAPState *s = net_tap_fd_init(peer, tap->helper ? "bridge" : "tap",
name, fd, vnet_hdr, queue_index,
- tap->has_local_migration_supported,
- tap->local_migration_supported);
+ tap->has_x_local_migration_supported,
+ tap->x_local_migration_supported);
bool sndbuf_required = tap->has_sndbuf;
int sndbuf =
(tap->has_sndbuf && tap->sndbuf) ? MIN(tap->sndbuf, INT_MAX) : INT_MAX;
@@ -1130,7 +1130,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
return -1;
}
- incoming_fds = tap->local_migration_supported && migrate_local() &&
+ incoming_fds = tap->x_local_migration_supported && migrate_local() &&
runstate_check(RUN_STATE_INMIGRATE);
if (incoming_fds &&
@@ -1140,7 +1140,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
!tap_is_explicit_no_script("downscript", tap->downscript))) {
error_setg(errp, "Local incoming migration of TAP device (-incoming, "
"migration parameter @local is set, "
- "TAP parameter @local-migration-supported is set) "
+ "TAP parameter @x-local-migration-supported is set) "
"is incompatible with "
"fd=, fds=, helper=, br=, ifname=, sndbuf= and vnet_hdr=, "
"and requires explicit empty script= and downscript=");
@@ -1168,8 +1168,8 @@ int net_init_tap(const Netdev *netdev, const char *name,
if (incoming_fds) {
for (i = 0; i < queues; i++) {
TAPState *s = new_tap(peer, "tap", name, i,
- tap->has_local_migration_supported,
- tap->local_migration_supported);
+ tap->has_x_local_migration_supported,
+ tap->x_local_migration_supported);
qemu_set_info_str(&s->nc, "incoming");
s->fd = -1;
diff --git a/qapi/net.json b/qapi/net.json
index d0d6e303b0d..e244cc62658 100644
--- a/qapi/net.json
+++ b/qapi/net.json
@@ -435,7 +435,7 @@
# @poll-us: maximum number of microseconds that could be spent on busy
# polling for tap (since 2.7)
#
-# @local-migration-supported: enable local migration for this TAP
+# @x-local-migration-supported: enable local migration for this TAP
# backend. When set, local migration is enabled/disabled by
# migration parameter @local for this TAP backend. When unset,
# migration parameter @local is ignored for this TAP backend.
@@ -447,13 +447,17 @@
# after creating TAP backend with @local-migration-supporeted
# parameter set) will simply fail.
# Moreover, when QEMU is in incoming migration state, migration
-# parameter @local is set and @local-migration-supported is set,
+# parameter @local is set and @x-local-migration-supported is set,
# the following options are not supported and must not be set:
# @fd, @fds, @helper, @br, @ifname, @sndbuf, @vnet_hdr.
# Additionally in this case @script and @downscipt must be
# explicitly disabled (empty strings or "no").
# (Since 11.2)
#
+# Features:
+#
+# @unstable: Member @x-local-migration-supported is experimental.
+#
# Since: 1.2
##
{ 'struct': 'NetdevTapOptions',
@@ -473,7 +477,8 @@
'*vhostforce': 'bool',
'*queues': 'uint32',
'*poll-us': 'uint32',
- '*local-migration-supported': 'bool' } }
+ '*x-local-migration-supported': {
+ 'type': 'bool', 'features' : [ 'unstable'] } } }
##
# @NetdevSocketOptions:
diff --git a/tests/functional/x86_64/test_tap_migration.py b/tests/functional/x86_64/test_tap_migration.py
index bcc0a60dfe9..5edf3f0fee2 100755
--- a/tests/functional/x86_64/test_tap_migration.py
+++ b/tests/functional/x86_64/test_tap_migration.py
@@ -329,7 +329,7 @@ def add_virtio_net(
"queues": 4,
"script": "no",
"downscript": "no",
- "local-migration-supported": local,
+ "x-local-migration-supported": local,
}
if not (local and incoming):
--
Best regards,
Vladimir
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH v19 13/15] net/tap: support local migration with virtio-net
2026-07-14 15:42 ` [PATCH v19 13/15] net/tap: support local migration with virtio-net Vladimir Sementsov-Ogievskiy
2026-07-15 8:10 ` Vladimir Sementsov-Ogievskiy
@ 2026-07-15 14:54 ` Chaney, Ben
1 sibling, 0 replies; 32+ messages in thread
From: Chaney, Ben @ 2026-07-15 14:54 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy, jasowang@redhat.com, mst@redhat.com
Cc: armbru@redhat.com, peterx@redhat.com, farosas@suse.de,
raphael.s.norwitz@gmail.com, qemu-devel@nongnu.org,
berrange@redhat.com, pbonzini@redhat.com, yc-core@yandex-team.ru,
mark.caveayland@nutanix.com, Jason Wang, Eric Blake
On 7/14/26, 11:44 AM, "Vladimir Sementsov-Ogievskiy" <vsementsov@yandex-team.ru <mailto:vsementsov@yandex-team.ru>> wrote:
> + if (has_local_migration_supported) {
> + s->local_migration_supported = local_migration_supported;
> + }
> +
> + vmstate_register(VMSTATE_IF(s), VMSTATE_INSTANCE_ID_ANY, &vmstate_tap, s);
> +
> return s;
> }
A comment on vmstate_register says:
> * New code shouldn't be using this function as QOM-ified devices have
> * dc->vmsd to store the serialisation description.
Is it possible to use that interface here?
^ permalink raw reply [flat|nested] 32+ messages in thread
* [PATCH v19 14/15] tests/functional: add skipWithoutSudo() decorator
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (12 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 13/15] net/tap: support local migration with virtio-net Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-14 15:42 ` [PATCH v19 15/15] tests/functional: add test_tap_migration Vladimir Sementsov-Ogievskiy
` (2 subsequent siblings)
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Thomas Huth, Lei Yang, Maksim Davydov, Thomas Huth,
Philippe Mathieu-Daudé
To be used in the next commit: that would be a test for TAP
networking, and it will need to setup TAP device.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Maksim Davydov <davydov-max@yandex-team.ru>
Reviewed-by: Ben Chaney <bchaney@akamai.com>
---
tests/functional/qemu_test/decorators.py | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/tests/functional/qemu_test/decorators.py b/tests/functional/qemu_test/decorators.py
index fcf236ecfdf..aa135acc785 100644
--- a/tests/functional/qemu_test/decorators.py
+++ b/tests/functional/qemu_test/decorators.py
@@ -6,6 +6,7 @@
import os
import platform
import resource
+import subprocess
from unittest import skipIf, skipUnless
from .cmd import which
@@ -177,3 +178,18 @@ def skipLockedMemoryTest(locked_memory):
ulimit_memory == resource.RLIM_INFINITY or ulimit_memory >= locked_memory * 1024,
f'Test required {locked_memory} kB of available locked memory',
)
+
+'''
+Decorator to skip execution of a test if passwordless
+sudo command is not available.
+'''
+def skipWithoutSudo():
+ proc = subprocess.run(["sudo", "-n", "/bin/true"],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ universal_newlines=True,
+ check=False)
+
+ return skipUnless(proc.returncode == 0,
+ f'requires password-less sudo access: {proc.stdout}')
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* [PATCH v19 15/15] tests/functional: add test_tap_migration
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (13 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 14/15] tests/functional: add skipWithoutSudo() decorator Vladimir Sementsov-Ogievskiy
@ 2026-07-14 15:42 ` Vladimir Sementsov-Ogievskiy
2026-07-15 14:46 ` [PATCH v19 00/15] virtio-net: live-TAP local migration Chaney, Ben
2026-07-15 15:01 ` Michael Tokarev
16 siblings, 0 replies; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-14 15:42 UTC (permalink / raw)
To: jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, vsementsov,
qemu-devel, berrange, pbonzini, yc-core, mark.caveayland,
Zhao Liu
Add test for a new local-migration migration of virtio-net/tap, with fd
passing through UNIX socket.
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Ben Chaney <bchaney@akamai.com>
---
tests/functional/x86_64/meson.build | 1 +
tests/functional/x86_64/test_tap_migration.py | 455 ++++++++++++++++++
2 files changed, 456 insertions(+)
create mode 100755 tests/functional/x86_64/test_tap_migration.py
diff --git a/tests/functional/x86_64/meson.build b/tests/functional/x86_64/meson.build
index 27b31f2e966..eaf2ec0005a 100644
--- a/tests/functional/x86_64/meson.build
+++ b/tests/functional/x86_64/meson.build
@@ -47,4 +47,5 @@ tests_x86_64_system_thorough = [
'virtio_balloon',
'virtio_gpu',
'rebuild_vmfd',
+ 'tap_migration',
]
diff --git a/tests/functional/x86_64/test_tap_migration.py b/tests/functional/x86_64/test_tap_migration.py
new file mode 100755
index 00000000000..bcc0a60dfe9
--- /dev/null
+++ b/tests/functional/x86_64/test_tap_migration.py
@@ -0,0 +1,455 @@
+#!/usr/bin/env python3
+#
+# Functional test that tests TAP local migration
+# with fd passing
+#
+# Copyright (c) Yandex Technologies LLC, 2026
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import os
+import time
+import subprocess
+from subprocess import run
+import signal
+import ctypes
+import ctypes.util
+import unittest
+from contextlib import contextmanager, ExitStack
+from typing import Tuple
+
+from qemu_test import (
+ LinuxKernelTest,
+ Asset,
+ exec_command_and_wait_for_pattern,
+)
+from qemu_test.decorators import skipWithoutSudo
+
+
+GUEST_IP = "192.168.100.2"
+GUEST_IP_MASK = f"{GUEST_IP}/24"
+GUEST_MAC = "d6:0d:75:f8:0f:b7"
+HOST_IP = "192.168.100.1"
+HOST_IP_MASK = f"{HOST_IP}/24"
+TAP_ID = "tap0"
+TAP_ID2 = "tap1"
+TAP_MAC = "e6:1d:44:b5:03:5d"
+NETNS = f"qemu_test_ns_{os.getpid()}"
+
+
+def ip(args, check=True) -> None:
+ """Run ip command with sudo"""
+ run(["sudo", "ip"] + args, check=check)
+
+
+@contextmanager
+def switch_netns(netns_name):
+ libc = ctypes.CDLL(ctypes.util.find_library("c"))
+ netns_path = f"/var/run/netns/{netns_name}"
+
+ def switch_to_fd(fd, check: bool = False):
+ """Switch to netns by file descriptor"""
+ SYS_setns = 308
+ CLONE_NEWNET = 0x40000000
+ ret = libc.syscall(SYS_setns, fd, CLONE_NEWNET)
+ if check and ret != 0:
+ raise RuntimeError("syscall SETNS failed")
+
+ with ExitStack() as stack:
+ original_netns_fd = os.open("/proc/self/ns/net", os.O_RDONLY)
+ stack.callback(os.close, original_netns_fd)
+
+ ip(["netns", "add", netns_name])
+ stack.callback(ip, ["netns", "del", netns_name], check=False)
+
+ new_netns_fd = os.open(netns_path, os.O_RDONLY)
+ stack.callback(os.close, new_netns_fd)
+
+ switch_to_fd(new_netns_fd)
+ stack.callback(switch_to_fd, original_netns_fd, check=False)
+
+ yield
+
+
+def del_tap(tap_name: str = TAP_ID) -> None:
+ ip(["tuntap", "del", tap_name, "mode", "tap", "multi_queue"], check=False)
+
+
+def init_tap(tap_name: str = TAP_ID, with_ip: bool = True) -> None:
+ ip(["tuntap", "add", "dev", tap_name, "mode", "tap", "multi_queue"])
+ if with_ip:
+ ip(["link", "set", "dev", tap_name, "address", TAP_MAC])
+ ip(["addr", "add", HOST_IP_MASK, "dev", tap_name])
+ ip(["link", "set", tap_name, "up"])
+
+
+def switch_network_to_tap2() -> None:
+ ip(["link", "set", TAP_ID2, "down"])
+ ip(["link", "set", TAP_ID, "down"])
+ ip(["addr", "delete", HOST_IP_MASK, "dev", TAP_ID])
+ ip(["link", "set", "dev", TAP_ID2, "address", TAP_MAC])
+ ip(["addr", "add", HOST_IP_MASK, "dev", TAP_ID2])
+ ip(["link", "set", TAP_ID2, "up"])
+
+
+def parse_ping_line(line: str) -> float:
+ # suspect lines like
+ # [1748524876.590509] 64 bytes from 94.245.155.3 \
+ # (94.245.155.3): icmp_seq=1 ttl=250 time=101 ms
+ spl = line.split()
+ return float(spl[0][1:-1])
+
+
+def parse_ping_output(out) -> Tuple[bool, float, float]:
+ lines = [x for x in out.split("\n") if x.startswith("[")]
+
+ try:
+ first_no_ans = next(
+ (ind for ind in range(len(lines)) if lines[ind][20:26] == "no ans")
+ )
+ except StopIteration:
+ return False, parse_ping_line(lines[0]), parse_ping_line(lines[-1])
+
+ last_no_ans = next(
+ ind
+ for ind in range(len(lines) - 1, -1, -1)
+ if lines[ind][20:26] == "no ans"
+ )
+
+ return (
+ True,
+ parse_ping_line(lines[first_no_ans]),
+ parse_ping_line(lines[last_no_ans]),
+ )
+
+
+def wait_migration_finish(source_vm, target_vm):
+ migr_events = (
+ ("MIGRATION", {"data": {"status": "completed"}}),
+ ("MIGRATION", {"data": {"status": "failed"}}),
+ )
+
+ source_e = source_vm.events_wait(migr_events)["data"]
+ target_e = target_vm.events_wait(migr_events)["data"]
+
+ source_s = source_vm.cmd("query-status")["status"]
+ target_s = target_vm.cmd("query-status")["status"]
+
+ assert (
+ source_e["status"] == "completed"
+ and target_e["status"] == "completed"
+ and source_s == "postmigrate"
+ and target_s == "paused"
+ ), f"""Migration failed:
+ SRC status: {source_s}
+ SRC event: {source_e}
+ TGT status: {target_s}
+ TGT event:{target_e}"""
+
+
+@skipWithoutSudo()
+class TAPFdMigration(LinuxKernelTest):
+
+ ASSET_KERNEL = Asset(
+ (
+ "https://archives.fedoraproject.org/pub/archive/fedora/linux/releases"
+ "/31/Server/x86_64/os/images/pxeboot/vmlinuz"
+ ),
+ "d4738d03dbbe083ca610d0821d0a8f1488bebbdccef54ce33e3adb35fda00129",
+ )
+
+ ASSET_INITRD = Asset(
+ (
+ "https://archives.fedoraproject.org/pub/archive/fedora/linux/releases"
+ "/31/Server/x86_64/os/images/pxeboot/initrd.img"
+ ),
+ "277cd6c7adf77c7e63d73bbb2cded8ef9e2d3a2f100000e92ff1f8396513cd8b",
+ )
+
+ ASSET_ALPINE_ISO = Asset(
+ (
+ "https://dl-cdn.alpinelinux.org/"
+ "alpine/v3.22/releases/x86_64/alpine-standard-3.22.1-x86_64.iso"
+ ),
+ "96d1b44ea1b8a5a884f193526d92edb4676054e9fa903ad2f016441a0fe13089",
+ )
+
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+
+ try:
+ cls.netns_context = switch_netns(NETNS)
+ cls.netns_context.__enter__()
+ except (OSError, subprocess.CalledProcessError) as e:
+ raise unittest.SkipTest(f"can't switch network namespace: {e}")
+
+ @classmethod
+ def tearDownClass(cls):
+ if hasattr(cls, "netns_context"):
+ cls.netns_context.__exit__(None, None, None)
+ super().tearDownClass()
+
+ def setUp(self):
+ super().setUp()
+
+ init_tap()
+
+ self.outer_ping_proc = None
+ self.shm_path = None
+
+ def tearDown(self):
+ try:
+ del_tap(TAP_ID)
+ del_tap(TAP_ID2)
+
+ if self.outer_ping_proc:
+ self.stop_outer_ping()
+
+ if self.shm_path:
+ os.unlink(self.shm_path)
+ finally:
+ super().tearDown()
+
+ def start_outer_ping(self) -> None:
+ assert self.outer_ping_proc is None
+ self.outer_ping_log = self.scratch_file("ping.log")
+ with open(self.outer_ping_log, "w") as f:
+ self.outer_ping_proc = subprocess.Popen(
+ ["ping", "-i", "0", "-O", "-D", GUEST_IP],
+ text=True,
+ stdout=f,
+ )
+
+ def stop_outer_ping(self) -> str:
+ assert self.outer_ping_proc
+ self.outer_ping_proc.send_signal(signal.SIGINT)
+
+ self.outer_ping_proc.communicate(timeout=5)
+ self.outer_ping_proc = None
+
+ with open(self.outer_ping_log) as f:
+ return f.read()
+
+ def stop_ping_and_check(self, stop_time, resume_time):
+ ping_res = self.stop_outer_ping()
+
+ discon, a, b = parse_ping_output(ping_res)
+
+ if not discon:
+ text = (
+ f"STOP: {stop_time}, RESUME: {resume_time}," f"PING: {a} - {b}"
+ )
+ if a > stop_time or b < resume_time:
+ self.fail(f"PING failed: {text}")
+ self.log.info(f"PING: no packets lost: {text}")
+ return
+
+ text = (
+ f"STOP: {stop_time}, RESUME: {resume_time},"
+ f"PING: disconnect: {a} - {b}"
+ )
+ self.log.info(text)
+ eps = 0.05
+ if a < stop_time - eps or b > resume_time + eps:
+ self.fail(text)
+
+ def one_ping_from_guest(self, vm) -> None:
+ exec_command_and_wait_for_pattern(
+ self,
+ f"ping -c 1 -W 1 {HOST_IP}",
+ "1 packets transmitted, 1 packets received",
+ "1 packets transmitted, 0 packets received",
+ vm=vm,
+ )
+ self.wait_for_console_pattern("# ", vm=vm)
+
+ def one_ping_from_host(self) -> None:
+ run(
+ ["ping", "-c", "1", "-W", "1", GUEST_IP],
+ stdout=subprocess.DEVNULL,
+ check=True,
+ )
+
+ def setup_shared_memory(self):
+ self.shm_path = f"/dev/shm/qemu_test_{os.getpid()}"
+
+ try:
+ with open(self.shm_path, "wb") as f:
+ f.write(b"\0" * (1024 * 1024 * 1024)) # 1GB
+ except Exception as e:
+ self.fail(f"Failed to create shared memory file: {e}")
+
+ def prepare_and_launch_vm(
+ self, shm_path, vhost, incoming=False, vm=None, local=True
+ ):
+ if not vm:
+ vm = self.vm
+
+ vm.set_console()
+ vm.add_args("-accel", "kvm")
+ vm.add_args("-device", "pcie-pci-bridge,id=pci.1,bus=pcie.0")
+ vm.add_args("-m", "1G")
+
+ vm.add_args(
+ "-object",
+ f"memory-backend-file,id=ram0,size=1G,mem-path={shm_path},share=on",
+ )
+ vm.add_args("-machine", "memory-backend=ram0")
+
+ vm.add_args(
+ "-drive",
+ f"file={self.ASSET_ALPINE_ISO.fetch()},media=cdrom,format=raw",
+ )
+
+ vm.add_args("-S")
+
+ if incoming:
+ vm.add_args("-incoming", "defer")
+
+ vm_s = "target" if incoming else "source"
+ self.log.info(f"Launching {vm_s} VM")
+ vm.launch()
+
+ if not local:
+ tap_name = TAP_ID2 if incoming else TAP_ID
+ else:
+ tap_name = TAP_ID
+
+ self.set_migration_capabilities(vm, local)
+ self.add_virtio_net(vm, vhost, tap_name, local, incoming)
+
+ def add_virtio_net(
+ self, vm, vhost: bool, tap_name: str, local: bool, incoming: bool
+ ):
+ netdev_params = {
+ "id": "netdev.1",
+ "vhost": vhost,
+ "type": "tap",
+ "queues": 4,
+ "script": "no",
+ "downscript": "no",
+ "local-migration-supported": local,
+ }
+
+ if not (local and incoming):
+ netdev_params["vnet_hdr"] = True
+ netdev_params["ifname"] = tap_name
+
+ vm.cmd("netdev_add", netdev_params)
+
+ vm.cmd(
+ "device_add",
+ driver="virtio-net-pci",
+ romfile="",
+ id="vnet.1",
+ netdev="netdev.1",
+ mq=True,
+ vectors=18,
+ bus="pci.1",
+ mac=GUEST_MAC,
+ disable_legacy="off",
+ )
+
+ def set_migration_capabilities(self, vm, local=True):
+ vm.cmd(
+ "migrate-set-capabilities",
+ {
+ "capabilities": [
+ {"capability": "events", "state": True},
+ {"capability": "x-ignore-shared", "state": True},
+ ]
+ },
+ )
+ vm.cmd("migrate-set-parameters", {"local": local})
+
+ def setup_guest_network(self) -> None:
+ exec_command_and_wait_for_pattern(self, "ip addr", "# ")
+ exec_command_and_wait_for_pattern(
+ self,
+ f"ip addr add {GUEST_IP_MASK} dev eth0 && "
+ "ip link set eth0 up && echo OK",
+ "OK",
+ )
+ self.wait_for_console_pattern("# ")
+
+ def do_test_tap_fd_migration(self, vhost, local=True):
+ self.require_accelerator("kvm")
+ self.set_machine("q35")
+
+ socket_dir = self.socket_dir()
+ migration_socket = os.path.join(socket_dir.name, "migration.sock")
+
+ self.setup_shared_memory()
+
+ # Setup second TAP if needed
+ if not local:
+ del_tap(TAP_ID2)
+ init_tap(TAP_ID2, with_ip=False)
+
+ self.prepare_and_launch_vm(self.shm_path, vhost, local=local)
+ self.vm.cmd("cont")
+ self.wait_for_console_pattern("login:")
+ exec_command_and_wait_for_pattern(self, "root", "# ")
+
+ self.setup_guest_network()
+
+ self.one_ping_from_guest(self.vm)
+ self.one_ping_from_host()
+ self.start_outer_ping()
+
+ # Get some successful pings before migration
+ time.sleep(0.5)
+
+ target_vm = self.get_vm(name="target")
+ self.prepare_and_launch_vm(
+ self.shm_path,
+ vhost,
+ incoming=True,
+ vm=target_vm,
+ local=local,
+ )
+
+ target_vm.cmd("migrate-incoming", {"uri": f"unix:{migration_socket}"})
+
+ self.log.info("Starting migration")
+ freeze_start = time.time()
+ self.vm.cmd("migrate", {"uri": f"unix:{migration_socket}"})
+
+ self.log.info("Waiting for migration completion")
+ wait_migration_finish(self.vm, target_vm)
+
+ # Switch network to tap1 if not using local-migration
+ if not local:
+ switch_network_to_tap2()
+
+ target_vm.cmd("cont")
+ freeze_end = time.time()
+
+ self.vm.shutdown()
+
+ self.log.info("Verifying PING on target VM after migration")
+ self.one_ping_from_guest(target_vm)
+ self.one_ping_from_host()
+
+ # And a bit more pings after source shutdown
+ time.sleep(0.3)
+ self.stop_ping_and_check(freeze_start, freeze_end)
+
+ target_vm.shutdown()
+
+ def test_tap_fd_migration(self):
+ self.do_test_tap_fd_migration(False)
+
+ def test_tap_fd_migration_vhost(self):
+ self.do_test_tap_fd_migration(True)
+
+ def test_tap_new_tap_migration(self):
+ self.do_test_tap_fd_migration(False, local=False)
+
+ def test_tap_new_tap_migration_vhost(self):
+ self.do_test_tap_fd_migration(True, local=False)
+
+
+if __name__ == "__main__":
+ LinuxKernelTest.main()
--
2.43.0
^ permalink raw reply related [flat|nested] 32+ messages in thread* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (14 preceding siblings ...)
2026-07-14 15:42 ` [PATCH v19 15/15] tests/functional: add test_tap_migration Vladimir Sementsov-Ogievskiy
@ 2026-07-15 14:46 ` Chaney, Ben
2026-07-15 15:01 ` Michael Tokarev
16 siblings, 0 replies; 32+ messages in thread
From: Chaney, Ben @ 2026-07-15 14:46 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy, jasowang@redhat.com, mst@redhat.com
Cc: armbru@redhat.com, peterx@redhat.com, farosas@suse.de,
raphael.s.norwitz@gmail.com, qemu-devel@nongnu.org,
berrange@redhat.com, pbonzini@redhat.com, yc-core@yandex-team.ru,
mark.caveayland@nutanix.com
On 7/14/26, 11:43 AM, "Vladimir Sementsov-Ogievskiy" <vsementsov@yandex-team.ru <mailto:vsementsov@yandex-team.ru>> wrote:
> Hi all!
>
>
> Here is a migration for TAP net backend, including its properties and
> open fds.
Reviewed-by: Ben Chaney <bchaney@akamai.com>
I've gone through this patch set again. I had a few minor questions that I'll send inline, but overall LGTM!
Thanks,
Ben
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-14 15:42 [PATCH v19 00/15] virtio-net: live-TAP local migration Vladimir Sementsov-Ogievskiy
` (15 preceding siblings ...)
2026-07-15 14:46 ` [PATCH v19 00/15] virtio-net: live-TAP local migration Chaney, Ben
@ 2026-07-15 15:01 ` Michael Tokarev
2026-07-15 15:48 ` Michael S. Tsirkin
2026-07-15 20:10 ` Vladimir Sementsov-Ogievskiy
16 siblings, 2 replies; 32+ messages in thread
From: Michael Tokarev @ 2026-07-15 15:01 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy, jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, qemu-devel,
berrange, pbonzini, yc-core, mark.caveayland
On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> Hi all!
>
> Here is a migration for TAP net backend, including its properties and
> open fds.
>
> With this new feature, management software doesn't need to initialize
> new TAP and do a switch to it. Nothing should be done around
> virtio-net in local migration: it just migrates and continues to use
> same TAP device. So we avoid extra logic in management software, extra
> allocations in kernel (for new TAP), and corresponding extra delay in
> migration downtime.
This is quite a big patch set, - is this really worth the effort to do
all this just for *local* migration? What's the possible use case for
this in real, - am I right this is just about upgrading the host qemu?
And with that in mind, isn't it sufficient to use what we already have
(namely, create new tap, start new qemu instance, and migrate the usual
way), and tolerate some very minor downtime while the networking code
learns the new network topology (isn't it happening almost instantly
anyway, and if not, the management can help by sending gratitious ARP)?
I wonder what's the use for this at yandex?
Thanks,
/mjt
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 15:01 ` Michael Tokarev
@ 2026-07-15 15:48 ` Michael S. Tsirkin
2026-07-15 15:52 ` Daniel P. Berrangé
2026-07-15 20:10 ` Vladimir Sementsov-Ogievskiy
1 sibling, 1 reply; 32+ messages in thread
From: Michael S. Tsirkin @ 2026-07-15 15:48 UTC (permalink / raw)
To: Michael Tokarev
Cc: Vladimir Sementsov-Ogievskiy, jasowang, armbru, peterx, farosas,
raphael.s.norwitz, bchaney, qemu-devel, berrange, pbonzini,
yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
> On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > Hi all!
> >
> > Here is a migration for TAP net backend, including its properties and
> > open fds.
> >
> > With this new feature, management software doesn't need to initialize
> > new TAP and do a switch to it. Nothing should be done around
> > virtio-net in local migration: it just migrates and continues to use
> > same TAP device. So we avoid extra logic in management software, extra
> > allocations in kernel (for new TAP), and corresponding extra delay in
> > migration downtime.
>
> This is quite a big patch set, - is this really worth the effort to do
> all this just for *local* migration? What's the possible use case for
> this in real, - am I right this is just about upgrading the host qemu?
> And with that in mind, isn't it sufficient to use what we already have
> (namely, create new tap, start new qemu instance, and migrate the usual
> way), and tolerate some very minor downtime while the networking code
> learns the new network topology (isn't it happening almost instantly
> anyway, and if not, the management can help by sending gratitious ARP)?
>
> I wonder what's the use for this at yandex?
>
> Thanks,
>
> /mjt
Well just theoretically, imagine a big VM, reserving twice the amount
of memory just to migrate is not nice at all.
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 15:48 ` Michael S. Tsirkin
@ 2026-07-15 15:52 ` Daniel P. Berrangé
2026-07-15 16:00 ` Peter Xu
0 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrangé @ 2026-07-15 15:52 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: Michael Tokarev, Vladimir Sementsov-Ogievskiy, jasowang, armbru,
peterx, farosas, raphael.s.norwitz, bchaney, qemu-devel, pbonzini,
yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
> On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
> > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > Hi all!
> > >
> > > Here is a migration for TAP net backend, including its properties and
> > > open fds.
> > >
> > > With this new feature, management software doesn't need to initialize
> > > new TAP and do a switch to it. Nothing should be done around
> > > virtio-net in local migration: it just migrates and continues to use
> > > same TAP device. So we avoid extra logic in management software, extra
> > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > migration downtime.
> >
> > This is quite a big patch set, - is this really worth the effort to do
> > all this just for *local* migration? What's the possible use case for
> > this in real, - am I right this is just about upgrading the host qemu?
> > And with that in mind, isn't it sufficient to use what we already have
> > (namely, create new tap, start new qemu instance, and migrate the usual
> > way), and tolerate some very minor downtime while the networking code
> > learns the new network topology (isn't it happening almost instantly
> > anyway, and if not, the management can help by sending gratitious ARP)?
> >
> > I wonder what's the use for this at yandex?
> >
> > Thanks,
> >
> > /mjt
>
> Well just theoretically, imagine a big VM, reserving twice the amount
> of memory just to migrate is not nice at all.
Don't we already have the ability to skip memory transfer by setting
the "x-ignore-shared" capability, assuming the VM RAM has a shared
memory backing.
With regards,
Daniel
--
|: https://berrange.com ~~ https://hachyderm.io/@berrange :|
|: https://libvirt.org ~~ https://entangle-photo.org :|
|: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com :|
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 15:52 ` Daniel P. Berrangé
@ 2026-07-15 16:00 ` Peter Xu
2026-07-15 20:21 ` Vladimir Sementsov-Ogievskiy
0 siblings, 1 reply; 32+ messages in thread
From: Peter Xu @ 2026-07-15 16:00 UTC (permalink / raw)
To: Daniel P. Berrangé
Cc: Michael S. Tsirkin, Michael Tokarev, Vladimir Sementsov-Ogievskiy,
jasowang, armbru, farosas, raphael.s.norwitz, bchaney, qemu-devel,
pbonzini, yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 04:52:48PM +0100, Daniel P. Berrangé wrote:
> On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
> > On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
> > > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > > Hi all!
> > > >
> > > > Here is a migration for TAP net backend, including its properties and
> > > > open fds.
> > > >
> > > > With this new feature, management software doesn't need to initialize
> > > > new TAP and do a switch to it. Nothing should be done around
> > > > virtio-net in local migration: it just migrates and continues to use
> > > > same TAP device. So we avoid extra logic in management software, extra
> > > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > > migration downtime.
> > >
> > > This is quite a big patch set, - is this really worth the effort to do
> > > all this just for *local* migration? What's the possible use case for
> > > this in real, - am I right this is just about upgrading the host qemu?
> > > And with that in mind, isn't it sufficient to use what we already have
> > > (namely, create new tap, start new qemu instance, and migrate the usual
> > > way), and tolerate some very minor downtime while the networking code
> > > learns the new network topology (isn't it happening almost instantly
> > > anyway, and if not, the management can help by sending gratitious ARP)?
> > >
> > > I wonder what's the use for this at yandex?
> > >
> > > Thanks,
> > >
> > > /mjt
> >
> > Well just theoretically, imagine a big VM, reserving twice the amount
> > of memory just to migrate is not nice at all.
>
> Don't we already have the ability to skip memory transfer by setting
> the "x-ignore-shared" capability, assuming the VM RAM has a shared
> memory backing.
Right, IIUC all similar single-host migrations like this series or CPR (or
anything else...) should always need to enable x-ignore-shared in the first
place. That's almost always the starting point of optimizing local
migrations.. no matter how the memory will be shared (by the same pool of
page cache, or persisted over kexec, etc.).
Thanks,
--
Peter Xu
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 16:00 ` Peter Xu
@ 2026-07-15 20:21 ` Vladimir Sementsov-Ogievskiy
2026-07-15 20:32 ` Michael S. Tsirkin
0 siblings, 1 reply; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-15 20:21 UTC (permalink / raw)
To: Peter Xu, Daniel P. Berrangé
Cc: Michael S. Tsirkin, Michael Tokarev, jasowang, armbru, farosas,
raphael.s.norwitz, bchaney, qemu-devel, pbonzini, yc-core,
mark.caveayland
On 15.07.26 19:00, Peter Xu wrote:
> On Wed, Jul 15, 2026 at 04:52:48PM +0100, Daniel P. Berrangé wrote:
>> On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
>>> On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
>>>> On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
>>>>> Hi all!
>>>>>
>>>>> Here is a migration for TAP net backend, including its properties and
>>>>> open fds.
>>>>>
>>>>> With this new feature, management software doesn't need to initialize
>>>>> new TAP and do a switch to it. Nothing should be done around
>>>>> virtio-net in local migration: it just migrates and continues to use
>>>>> same TAP device. So we avoid extra logic in management software, extra
>>>>> allocations in kernel (for new TAP), and corresponding extra delay in
>>>>> migration downtime.
>>>>
>>>> This is quite a big patch set, - is this really worth the effort to do
>>>> all this just for *local* migration? What's the possible use case for
>>>> this in real, - am I right this is just about upgrading the host qemu?
>>>> And with that in mind, isn't it sufficient to use what we already have
>>>> (namely, create new tap, start new qemu instance, and migrate the usual
>>>> way), and tolerate some very minor downtime while the networking code
>>>> learns the new network topology (isn't it happening almost instantly
>>>> anyway, and if not, the management can help by sending gratitious ARP)?
>>>>
>>>> I wonder what's the use for this at yandex?
>>>>
>>>> Thanks,
>>>>
>>>> /mjt
>>>
>>> Well just theoretically, imagine a big VM, reserving twice the amount
>>> of memory just to migrate is not nice at all.
>>
>> Don't we already have the ability to skip memory transfer by setting
>> the "x-ignore-shared" capability, assuming the VM RAM has a shared
>> memory backing.
>
> Right, IIUC all similar single-host migrations like this series or CPR (or
> anything else...) should always need to enable x-ignore-shared in the first
> place. That's almost always the starting point of optimizing local
> migrations.. no matter how the memory will be shared (by the same pool of
> page cache, or persisted over kexec, etc.).
>
Yes, sharing RAM between source and target + enabling x-ignore-shared is a first thing to do.
This series optimizes TAP recreating. Not only skip recreating but also allow to
exclude cloud-networking component form live-update entirely, making the process
simpler (less components involved), and as I already said, reducing corresponding
downtime.
--
Best regards,
Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 20:21 ` Vladimir Sementsov-Ogievskiy
@ 2026-07-15 20:32 ` Michael S. Tsirkin
2026-07-15 22:11 ` Vladimir Sementsov-Ogievskiy
0 siblings, 1 reply; 32+ messages in thread
From: Michael S. Tsirkin @ 2026-07-15 20:32 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy
Cc: Peter Xu, Daniel P. Berrangé, Michael Tokarev, jasowang,
armbru, farosas, raphael.s.norwitz, bchaney, qemu-devel, pbonzini,
yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 11:21:23PM +0300, Vladimir Sementsov-Ogievskiy wrote:
> On 15.07.26 19:00, Peter Xu wrote:
> > On Wed, Jul 15, 2026 at 04:52:48PM +0100, Daniel P. Berrangé wrote:
> > > On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
> > > > On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
> > > > > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > > > > Hi all!
> > > > > >
> > > > > > Here is a migration for TAP net backend, including its properties and
> > > > > > open fds.
> > > > > >
> > > > > > With this new feature, management software doesn't need to initialize
> > > > > > new TAP and do a switch to it. Nothing should be done around
> > > > > > virtio-net in local migration: it just migrates and continues to use
> > > > > > same TAP device. So we avoid extra logic in management software, extra
> > > > > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > > > > migration downtime.
> > > > >
> > > > > This is quite a big patch set, - is this really worth the effort to do
> > > > > all this just for *local* migration? What's the possible use case for
> > > > > this in real, - am I right this is just about upgrading the host qemu?
> > > > > And with that in mind, isn't it sufficient to use what we already have
> > > > > (namely, create new tap, start new qemu instance, and migrate the usual
> > > > > way), and tolerate some very minor downtime while the networking code
> > > > > learns the new network topology (isn't it happening almost instantly
> > > > > anyway, and if not, the management can help by sending gratitious ARP)?
> > > > >
> > > > > I wonder what's the use for this at yandex?
> > > > >
> > > > > Thanks,
> > > > >
> > > > > /mjt
> > > >
> > > > Well just theoretically, imagine a big VM, reserving twice the amount
> > > > of memory just to migrate is not nice at all.
> > >
> > > Don't we already have the ability to skip memory transfer by setting
> > > the "x-ignore-shared" capability, assuming the VM RAM has a shared
> > > memory backing.
> >
> > Right, IIUC all similar single-host migrations like this series or CPR (or
> > anything else...) should always need to enable x-ignore-shared in the first
> > place. That's almost always the starting point of optimizing local
> > migrations.. no matter how the memory will be shared (by the same pool of
> > page cache, or persisted over kexec, etc.).
> >
>
> Yes, sharing RAM between source and target + enabling x-ignore-shared is a first thing to do.
>
> This series optimizes TAP recreating. Not only skip recreating but also allow to
> exclude cloud-networking component form live-update entirely, making the process
> simpler (less components involved), and as I already said, reducing corresponding
> downtime.
>
> --
> Best regards,
> Vladimir
So can you explain, how is this better than
1. a persistent tap
2. a non persistent tap that some server gets a hold of
IOW why does qemu need to bother.
--
MST
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 20:32 ` Michael S. Tsirkin
@ 2026-07-15 22:11 ` Vladimir Sementsov-Ogievskiy
2026-07-15 22:45 ` Michael S. Tsirkin
0 siblings, 1 reply; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-15 22:11 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: Peter Xu, Daniel P. Berrangé, Michael Tokarev, jasowang,
armbru, farosas, raphael.s.norwitz, bchaney, qemu-devel, pbonzini,
yc-core, mark.caveayland
On 15.07.26 23:32, Michael S. Tsirkin wrote:
> On Wed, Jul 15, 2026 at 11:21:23PM +0300, Vladimir Sementsov-Ogievskiy wrote:
>> On 15.07.26 19:00, Peter Xu wrote:
>>> On Wed, Jul 15, 2026 at 04:52:48PM +0100, Daniel P. Berrangé wrote:
>>>> On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
>>>>> On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
>>>>>> On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
>>>>>>> Hi all!
>>>>>>>
>>>>>>> Here is a migration for TAP net backend, including its properties and
>>>>>>> open fds.
>>>>>>>
>>>>>>> With this new feature, management software doesn't need to initialize
>>>>>>> new TAP and do a switch to it. Nothing should be done around
>>>>>>> virtio-net in local migration: it just migrates and continues to use
>>>>>>> same TAP device. So we avoid extra logic in management software, extra
>>>>>>> allocations in kernel (for new TAP), and corresponding extra delay in
>>>>>>> migration downtime.
>>>>>>
>>>>>> This is quite a big patch set, - is this really worth the effort to do
>>>>>> all this just for *local* migration? What's the possible use case for
>>>>>> this in real, - am I right this is just about upgrading the host qemu?
>>>>>> And with that in mind, isn't it sufficient to use what we already have
>>>>>> (namely, create new tap, start new qemu instance, and migrate the usual
>>>>>> way), and tolerate some very minor downtime while the networking code
>>>>>> learns the new network topology (isn't it happening almost instantly
>>>>>> anyway, and if not, the management can help by sending gratitious ARP)?
>>>>>>
>>>>>> I wonder what's the use for this at yandex?
>>>>>>
>>>>>> Thanks,
>>>>>>
>>>>>> /mjt
>>>>>
>>>>> Well just theoretically, imagine a big VM, reserving twice the amount
>>>>> of memory just to migrate is not nice at all.
>>>>
>>>> Don't we already have the ability to skip memory transfer by setting
>>>> the "x-ignore-shared" capability, assuming the VM RAM has a shared
>>>> memory backing.
>>>
>>> Right, IIUC all similar single-host migrations like this series or CPR (or
>>> anything else...) should always need to enable x-ignore-shared in the first
>>> place. That's almost always the starting point of optimizing local
>>> migrations.. no matter how the memory will be shared (by the same pool of
>>> page cache, or persisted over kexec, etc.).
>>>
>>
>> Yes, sharing RAM between source and target + enabling x-ignore-shared is a first thing to do.
>>
>> This series optimizes TAP recreating. Not only skip recreating but also allow to
>> exclude cloud-networking component form live-update entirely, making the process
>> simpler (less components involved), and as I already said, reducing corresponding
>> downtime.
>>
>> --
>> Best regards,
>> Vladimir
>
> So can you explain, how is this better than
> 1. a persistent tap
You mean open same tap device both on source and target?
This will require some additional steps anyway, to avoid packet loss,
like keeping queues disabled on target until post_load.
Another thing is MAX_TAP_QUEUES=256 in kernel: this is a problem, if you have more
than 128 queues already opened on source. Seems cleaner just pass already opened
queues to the target.
And finally, on hosts with many CPUs, TAP queue allocate noticeable amount
of RAM, so having x2 queues during migration would be an overhead.
> 2. a non persistent tap that some server gets a hold of
You mean, just pass FDs externally, instead of using QEMUs migration stream?
That's possible. But requires mgmt tool to store (or get from source) and pass
these FDs. Requires mgmt to even know about these FDs. But why? QEMU already
can pass FDs through migration for vfio devices (CPR), why is TAP worse?
Like with persistent tap, it will require some changes in Qemu anyway, to avoid packet loss
(like patch 12/15 here).
>
> IOW why does qemu need to bother.
QEMU owns the TAP fd and has full knowledge of its state. Pushing this responsibility
to an external tool means the tool needs to understand QEMU internals just to pass
an fd that QEMU already has. I think, that's a worse separation of concerns.
Of course, there are other ways to do TAP local migration. But looking at wider
picture, where we want to migrate not only TAP, but also vfio devices (already
implemented as CPR migration, but may be updated to use similar approach as in
this series, to use one migration channel), vhost-user-blk (my another series
in flight) and vhost-user-fs (not yet published), vhost-vsock migration
("[PATCH v3 0/7] migration/cpr: support vhost-vsock devices" in flight series),
it seems a good generic approach: simply pass backends (including open FDs) to
the target, not involving mgmt. Qemu has full knowledge about these FDs and
owns the whole state. Migrating them in QEMU looks correct for me.
--
Best regards,
Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 22:11 ` Vladimir Sementsov-Ogievskiy
@ 2026-07-15 22:45 ` Michael S. Tsirkin
0 siblings, 0 replies; 32+ messages in thread
From: Michael S. Tsirkin @ 2026-07-15 22:45 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy
Cc: Peter Xu, Daniel P. Berrangé, Michael Tokarev, jasowang,
armbru, farosas, raphael.s.norwitz, bchaney, qemu-devel, pbonzini,
yc-core, mark.caveayland
On Thu, Jul 16, 2026 at 01:11:05AM +0300, Vladimir Sementsov-Ogievskiy wrote:
> On 15.07.26 23:32, Michael S. Tsirkin wrote:
> > On Wed, Jul 15, 2026 at 11:21:23PM +0300, Vladimir Sementsov-Ogievskiy wrote:
> > > On 15.07.26 19:00, Peter Xu wrote:
> > > > On Wed, Jul 15, 2026 at 04:52:48PM +0100, Daniel P. Berrangé wrote:
> > > > > On Wed, Jul 15, 2026 at 11:48:40AM -0400, Michael S. Tsirkin wrote:
> > > > > > On Wed, Jul 15, 2026 at 06:01:39PM +0300, Michael Tokarev wrote:
> > > > > > > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > > > > > > Hi all!
> > > > > > > >
> > > > > > > > Here is a migration for TAP net backend, including its properties and
> > > > > > > > open fds.
> > > > > > > >
> > > > > > > > With this new feature, management software doesn't need to initialize
> > > > > > > > new TAP and do a switch to it. Nothing should be done around
> > > > > > > > virtio-net in local migration: it just migrates and continues to use
> > > > > > > > same TAP device. So we avoid extra logic in management software, extra
> > > > > > > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > > > > > > migration downtime.
> > > > > > >
> > > > > > > This is quite a big patch set, - is this really worth the effort to do
> > > > > > > all this just for *local* migration? What's the possible use case for
> > > > > > > this in real, - am I right this is just about upgrading the host qemu?
> > > > > > > And with that in mind, isn't it sufficient to use what we already have
> > > > > > > (namely, create new tap, start new qemu instance, and migrate the usual
> > > > > > > way), and tolerate some very minor downtime while the networking code
> > > > > > > learns the new network topology (isn't it happening almost instantly
> > > > > > > anyway, and if not, the management can help by sending gratitious ARP)?
> > > > > > >
> > > > > > > I wonder what's the use for this at yandex?
> > > > > > >
> > > > > > > Thanks,
> > > > > > >
> > > > > > > /mjt
> > > > > >
> > > > > > Well just theoretically, imagine a big VM, reserving twice the amount
> > > > > > of memory just to migrate is not nice at all.
> > > > >
> > > > > Don't we already have the ability to skip memory transfer by setting
> > > > > the "x-ignore-shared" capability, assuming the VM RAM has a shared
> > > > > memory backing.
> > > >
> > > > Right, IIUC all similar single-host migrations like this series or CPR (or
> > > > anything else...) should always need to enable x-ignore-shared in the first
> > > > place. That's almost always the starting point of optimizing local
> > > > migrations.. no matter how the memory will be shared (by the same pool of
> > > > page cache, or persisted over kexec, etc.).
> > > >
> > >
> > > Yes, sharing RAM between source and target + enabling x-ignore-shared is a first thing to do.
> > >
> > > This series optimizes TAP recreating. Not only skip recreating but also allow to
> > > exclude cloud-networking component form live-update entirely, making the process
> > > simpler (less components involved), and as I already said, reducing corresponding
> > > downtime.
> > >
> > > --
> > > Best regards,
> > > Vladimir
> >
> > So can you explain, how is this better than
> > 1. a persistent tap
>
> You mean open same tap device both on source and target?
>
> This will require some additional steps anyway, to avoid packet loss,
> like keeping queues disabled on target until post_load.
>
> Another thing is MAX_TAP_QUEUES=256 in kernel: this is a problem, if you have more
> than 128 queues already opened on source. Seems cleaner just pass already opened
> queues to the target.
>
> And finally, on hosts with many CPUs, TAP queue allocate noticeable amount
> of RAM, so having x2 queues during migration would be an overhead.
ah I forgot. yes queues do get
> > 2. a non persistent tap that some server gets a hold of
>
> You mean, just pass FDs externally, instead of using QEMUs migration stream?
> That's possible. But requires mgmt tool to store (or get from source) and pass
> these FDs. Requires mgmt to even know about these FDs.
e.g. libvirt already does, right? it creates them?
> But why? QEMU already
> can pass FDs through migration for vfio devices (CPR), why is TAP worse?
it's not that it's worse. it's that we are growing bespoke mechanisms so far.
so if qemu gets tap fd on command line then what? how does that
interact?
> Like with persistent tap, it will require some changes in Qemu anyway, to avoid packet loss
> (like patch 12/15 here).
that one is more like a bugfix.
> >
> > IOW why does qemu need to bother.
>
> QEMU owns the TAP fd and has full knowledge of its state. Pushing this responsibility
> to an external tool means the tool needs to understand QEMU internals just to pass
> an fd that QEMU already has. I think, that's a worse separation of concerns.
>
> Of course, there are other ways to do TAP local migration. But looking at wider
> picture, where we want to migrate not only TAP, but also vfio devices (already
> implemented as CPR migration, but may be updated to use similar approach as in
> this series, to use one migration channel), vhost-user-blk (my another series
> in flight) and vhost-user-fs (not yet published), vhost-vsock migration
> ("[PATCH v3 0/7] migration/cpr: support vhost-vsock devices" in flight series),
> it seems a good generic approach: simply pass backends (including open FDs) to
> the target, not involving mgmt. Qemu has full knowledge about these FDs and
> owns the whole state. Migrating them in QEMU looks correct for me.
if you find a way to generalize things and reuse them for your
purposes without intrusive changes all over qemu, fine.
But this one is poking as far as frontend code even.
> --
> Best regards,
> Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 15:01 ` Michael Tokarev
2026-07-15 15:48 ` Michael S. Tsirkin
@ 2026-07-15 20:10 ` Vladimir Sementsov-Ogievskiy
2026-07-15 20:20 ` Michael S. Tsirkin
1 sibling, 1 reply; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-15 20:10 UTC (permalink / raw)
To: Michael Tokarev, jasowang, mst
Cc: armbru, peterx, farosas, raphael.s.norwitz, bchaney, qemu-devel,
berrange, pbonzini, yc-core, mark.caveayland
On 15.07.26 18:01, Michael Tokarev wrote:
> On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
>> Hi all!
>>
>> Here is a migration for TAP net backend, including its properties and
>> open fds.
>>
>> With this new feature, management software doesn't need to initialize
>> new TAP and do a switch to it. Nothing should be done around
>> virtio-net in local migration: it just migrates and continues to use
>> same TAP device. So we avoid extra logic in management software, extra
>> allocations in kernel (for new TAP), and corresponding extra delay in
>> migration downtime.
>
> This is quite a big patch set,
You probably haven't been following Steve's work (about 5 years) on
CPR Live Update :) My patch set is small.
> - is this really worth the effort to do
> all this just for *local* migration? What's the possible use case for
> this in real, - am I right this is just about upgrading the host qemu?
Exactly. You say "just for", but actually local migration is a lot more
"massive" operation for us. Remote migrations are done mostly to release the
physical server for service/redeploy (you should first migrate all the
vms to other servers). That's a relatively seldom operation.
On the contrary, when updating to new QEMU version, you migrate _all_
vms on _all_ servers. These (minimal) downtimes affects all the
customers, some are sensitive to freezes.
> And with that in mind, isn't it sufficient to use what we already have
> (namely, create new tap, start new qemu instance, and migrate the usual
> way), and tolerate some very minor downtime while the networking code
> learns the new network topology (isn't it happening almost instantly
> anyway, and if not, the management can help by sending gratitious ARP)?
>
> I wonder what's the use for this at yandex?
>
This series together with similar about vhost-user-blk local migration
gives several times win in freeze-time. It's significant for us.
--
Best regards,
Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 20:10 ` Vladimir Sementsov-Ogievskiy
@ 2026-07-15 20:20 ` Michael S. Tsirkin
2026-07-15 20:48 ` Vladimir Sementsov-Ogievskiy
0 siblings, 1 reply; 32+ messages in thread
From: Michael S. Tsirkin @ 2026-07-15 20:20 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy
Cc: Michael Tokarev, jasowang, armbru, peterx, farosas,
raphael.s.norwitz, bchaney, qemu-devel, berrange, pbonzini,
yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 11:10:28PM +0300, Vladimir Sementsov-Ogievskiy wrote:
> On 15.07.26 18:01, Michael Tokarev wrote:
> > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > Hi all!
> > >
> > > Here is a migration for TAP net backend, including its properties and
> > > open fds.
> > >
> > > With this new feature, management software doesn't need to initialize
> > > new TAP and do a switch to it. Nothing should be done around
> > > virtio-net in local migration: it just migrates and continues to use
> > > same TAP device. So we avoid extra logic in management software, extra
> > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > migration downtime.
> >
> > This is quite a big patch set,
>
> You probably haven't been following Steve's work (about 5 years) on
> CPR Live Update :) My patch set is small.
>
> > - is this really worth the effort to do
> > all this just for *local* migration? What's the possible use case for
> > this in real, - am I right this is just about upgrading the host qemu?
>
> Exactly. You say "just for", but actually local migration is a lot more
> "massive" operation for us. Remote migrations are done mostly to release the
> physical server for service/redeploy (you should first migrate all the
> vms to other servers). That's a relatively seldom operation.
>
> On the contrary, when updating to new QEMU version, you migrate _all_
> vms on _all_ servers. These (minimal) downtimes affects all the
> customers, some are sensitive to freezes.
>
> > And with that in mind, isn't it sufficient to use what we already have
> > (namely, create new tap, start new qemu instance, and migrate the usual
> > way), and tolerate some very minor downtime while the networking code
> > learns the new network topology (isn't it happening almost instantly
> > anyway, and if not, the management can help by sending gratitious ARP)?
> >
> > I wonder what's the use for this at yandex?
> >
>
> This series together with similar about vhost-user-blk local migration
> gives several times win in freeze-time. It's significant for us.
>
> --
> Best regards,
> Vladimir
I believe it is.
But let's focus on what exactly are we saving here.
It is not that clear.
Is it the overhead of tap losing state such as
bridge forgetting the tap mac. Or what?
--
MST
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 20:20 ` Michael S. Tsirkin
@ 2026-07-15 20:48 ` Vladimir Sementsov-Ogievskiy
2026-07-15 21:23 ` Michael S. Tsirkin
0 siblings, 1 reply; 32+ messages in thread
From: Vladimir Sementsov-Ogievskiy @ 2026-07-15 20:48 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: Michael Tokarev, jasowang, armbru, peterx, farosas,
raphael.s.norwitz, bchaney, qemu-devel, berrange, pbonzini,
yc-core, mark.caveayland
On 15.07.26 23:20, Michael S. Tsirkin wrote:
> On Wed, Jul 15, 2026 at 11:10:28PM +0300, Vladimir Sementsov-Ogievskiy wrote:
>> On 15.07.26 18:01, Michael Tokarev wrote:
>>> On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
>>>> Hi all!
>>>>
>>>> Here is a migration for TAP net backend, including its properties and
>>>> open fds.
>>>>
>>>> With this new feature, management software doesn't need to initialize
>>>> new TAP and do a switch to it. Nothing should be done around
>>>> virtio-net in local migration: it just migrates and continues to use
>>>> same TAP device. So we avoid extra logic in management software, extra
>>>> allocations in kernel (for new TAP), and corresponding extra delay in
>>>> migration downtime.
>>>
>>> This is quite a big patch set,
>>
>> You probably haven't been following Steve's work (about 5 years) on
>> CPR Live Update :) My patch set is small.
>>
>>> - is this really worth the effort to do
>>> all this just for *local* migration? What's the possible use case for
>>> this in real, - am I right this is just about upgrading the host qemu?
>>
>> Exactly. You say "just for", but actually local migration is a lot more
>> "massive" operation for us. Remote migrations are done mostly to release the
>> physical server for service/redeploy (you should first migrate all the
>> vms to other servers). That's a relatively seldom operation.
>>
>> On the contrary, when updating to new QEMU version, you migrate _all_
>> vms on _all_ servers. These (minimal) downtimes affects all the
>> customers, some are sensitive to freezes.
>>
>>> And with that in mind, isn't it sufficient to use what we already have
>>> (namely, create new tap, start new qemu instance, and migrate the usual
>>> way), and tolerate some very minor downtime while the networking code
>>> learns the new network topology (isn't it happening almost instantly
>>> anyway, and if not, the management can help by sending gratitious ARP)?
>>>
>>> I wonder what's the use for this at yandex?
>>>
>>
>> This series together with similar about vhost-user-blk local migration
>> gives several times win in freeze-time. It's significant for us.
>>
>> --
>> Best regards,
>> Vladimir
>
>
> I believe it is.
> But let's focus on what exactly are we saving here.
> It is not that clear.
>
> Is it the overhead of tap losing state such as
> bridge forgetting the tap mac. Or what?
>
I don't have a full expertize here, but the overhead is in switching
to a new TAP in our cloud virtual networking component. Could this
switching be optimized, to always work very fast? That's a good
question that I don't have an answer to. Probably yes.
We decided to go another way: drop extra components from the process,
and avoid any extra switching at all. Both cloud networking component, and
storage (with vhost-usr-blk live-udpate series) don't even know, that
QEMU is migrating. That seems to be a clear design for local migration,
and shows good results.
--
Best regards,
Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [PATCH v19 00/15] virtio-net: live-TAP local migration
2026-07-15 20:48 ` Vladimir Sementsov-Ogievskiy
@ 2026-07-15 21:23 ` Michael S. Tsirkin
0 siblings, 0 replies; 32+ messages in thread
From: Michael S. Tsirkin @ 2026-07-15 21:23 UTC (permalink / raw)
To: Vladimir Sementsov-Ogievskiy
Cc: Michael Tokarev, jasowang, armbru, peterx, farosas,
raphael.s.norwitz, bchaney, qemu-devel, berrange, pbonzini,
yc-core, mark.caveayland
On Wed, Jul 15, 2026 at 11:48:02PM +0300, Vladimir Sementsov-Ogievskiy wrote:
> On 15.07.26 23:20, Michael S. Tsirkin wrote:
> > On Wed, Jul 15, 2026 at 11:10:28PM +0300, Vladimir Sementsov-Ogievskiy wrote:
> > > On 15.07.26 18:01, Michael Tokarev wrote:
> > > > On 14.07.2026 18:42, Vladimir Sementsov-Ogievskiy wrote:
> > > > > Hi all!
> > > > >
> > > > > Here is a migration for TAP net backend, including its properties and
> > > > > open fds.
> > > > >
> > > > > With this new feature, management software doesn't need to initialize
> > > > > new TAP and do a switch to it. Nothing should be done around
> > > > > virtio-net in local migration: it just migrates and continues to use
> > > > > same TAP device. So we avoid extra logic in management software, extra
> > > > > allocations in kernel (for new TAP), and corresponding extra delay in
> > > > > migration downtime.
> > > >
> > > > This is quite a big patch set,
> > >
> > > You probably haven't been following Steve's work (about 5 years) on
> > > CPR Live Update :) My patch set is small.
> > >
> > > > - is this really worth the effort to do
> > > > all this just for *local* migration? What's the possible use case for
> > > > this in real, - am I right this is just about upgrading the host qemu?
> > >
> > > Exactly. You say "just for", but actually local migration is a lot more
> > > "massive" operation for us. Remote migrations are done mostly to release the
> > > physical server for service/redeploy (you should first migrate all the
> > > vms to other servers). That's a relatively seldom operation.
> > >
> > > On the contrary, when updating to new QEMU version, you migrate _all_
> > > vms on _all_ servers. These (minimal) downtimes affects all the
> > > customers, some are sensitive to freezes.
> > >
> > > > And with that in mind, isn't it sufficient to use what we already have
> > > > (namely, create new tap, start new qemu instance, and migrate the usual
> > > > way), and tolerate some very minor downtime while the networking code
> > > > learns the new network topology (isn't it happening almost instantly
> > > > anyway, and if not, the management can help by sending gratitious ARP)?
> > > >
> > > > I wonder what's the use for this at yandex?
> > > >
> > >
> > > This series together with similar about vhost-user-blk local migration
> > > gives several times win in freeze-time. It's significant for us.
> > >
> > > --
> > > Best regards,
> > > Vladimir
> >
> >
> > I believe it is.
> > But let's focus on what exactly are we saving here.
> > It is not that clear.
> >
> > Is it the overhead of tap losing state such as
> > bridge forgetting the tap mac. Or what?
> >
>
> I don't have a full expertize here, but the overhead is in switching
> to a new TAP in our cloud virtual networking component.
So what is wrong with
1. using a persistent TAP
or
2. starting a server and handing out these FDs?
> Could this
> switching be optimized, to always work very fast? That's a good
> question that I don't have an answer to. Probably yes.
>
> We decided to go another way: drop extra components from the process,
> and avoid any extra switching at all. Both cloud networking component, and
> storage (with vhost-usr-blk live-udpate series) don't even know, that
> QEMU is migrating. That seems to be a clear design for local migration,
> and shows good results.
>
> --
> Best regards,
> Vladimir
^ permalink raw reply [flat|nested] 32+ messages in thread