migration: stop dma while VM is stopped
v2 cover migration: stop dma while VM is stopped
Here's a patch that's much smaller: instead of trying to solve the whole problem, it fixes the specific bug I observe, that of net device traffic when vm is stopped confusing the bridge.
We can then slowly convert all other devices that need to be stopped on vmstop to this API.
Comments?
Michael S. Tsirkin (2):
char: separate device and system fd handlers
tap: mark fd handler as device
hw/vhost_net.c | 2 +- net/tap.c | 3 +- qemu-char.h | 6 ++- qemu-kvm.c | 2 +- qemu-tool.c | 10 +++++ vl.c | 117 ++++++++++++++++++++++++++++++++++++------------------- 6 files changed, 95 insertions(+), 45 deletions(-)
Signature · 1 line
1.7.3.2.91.g446ac
PATCH v2 1/2 char: separate device and system fd handlers
Create separate lists for system and device fd handlers. Device handlers will not run while vm is stopped. By default all fds are assumed system so they will keep running as before.
--- qemu-char.h | 6 +++- qemu-kvm.c | 2 +- qemu-tool.c | 10 +++++ vl.c | 117 ++++++++++++++++++++++++++++++++++++++--------------------- 4 files changed, 92 insertions(+), 43 deletions(-)
qemu-char.h +5 -1
@@ -101,7 +101,11 @@ CharDriverState *qemu_chr_open_eventfd(int eventfd);extern int term_escape_char;/* async I/O support */ - +int qemu_set_fd_handler3 (bool device,int fd, +IOCanReadHandler *fd_read_poll, +IOHandler *fd_read, +IOHandler *fd_write, +void *opaque); int qemu_set_fd_handler2(int fd, IOCanReadHandler *fd_read_poll, IOHandler *fd_read,
qemu-kvm.c +1 -1
@@ -1621,7 +1621,7 @@ int kvm_main_loop(void)fcntl (sigfd,F_SETFL ,O_NONBLOCK ); -qemu_set_fd_handler2 (sigfd,NULL , sigfd_handler,NULL , +qemu_set_fd_handler3 (true, sigfd,NULL , sigfd_handler,NULL , (void *)(unsigned long ) sigfd);pthread_cond_broadcast (&qemu_system_cond);
qemu-tool.c +10 -0
@@ -111,6 +111,16 @@ int qemu_set_fd_handler2(int fd,return 0 ; } +int qemu_set_fd_handler3 (bool device, +int fd, +IOCanReadHandler *fd_read_poll, +IOHandler *fd_read, +IOHandler *fd_write, +void *opaque) +{ +return 0 ; +} +int64_t qemu_get_clock (QEMUClock *clock) {qemu_timeval tv;
vl.c +76 -41
173 lines not on this page · raw message
Signature · 1 line
1.7.3.2.91.g446ac
[Qemu-devel] Re: [PATCHv2 1/2] char: separate device and system fd handlers
Quoted 18 lines · Michael S. Tsirkin
Create separate lists for system and device fd handlers. Device handlers will not run while vm is stopped. By default all fds are assumed system so they will keep running as before.
Signed-off-by Michael S. Tsirkin <[email protected]>--- qemu-char.h | 6 +++- qemu-kvm.c | 2 +- qemu-tool.c | 10 +++++ vl.c | 117 ++++++++++++++++++++++++++++++++++++++--------------------- 4 files changed, 92 insertions(+), 43 deletions(-)qemu-char.h +0
-0
qemu-char.h CharDriverState *qemu_chr_open_eventfd(int eventfd); · line 108
Quoted 9 lines
qemu-char.h +5
-1@@ -101,7 +101,11 @@ CharDriverState *qemu_chr_open_eventfd(int eventfd);extern int term_escape_char;/* async I/O support */ - +int qemu_set_fd_handler3 (bool device,int fd, +IOCanReadHandler *fd_read_poll, +IOHandler *fd_read, +IOHandler *fd_write, +void *opaque);
No this horror. Can't we just create:
qemu_set_device_handler()qemu_set_system_handler()
or whatever named you like?
qemu_set_fd_handler2 is already bad enough, adding another one just make things worse in my humble opinion.
qemu-char.h CharDriverState *qemu_chr_open_eventfd(int eventfd);
Quoted 12 lines
qemu-char.h +5
-0+int qemu_set_fd_handler3 (bool device, +int fd,IOCanReadHandler *fd_read_poll,IOHandler *fd_read,IOHandler *fd_write,void *opaque) { +IOHandlerRecordList *list;IOHandlerRecord *ioh; + list = device ? &device_io_handlers: &system_io_handlers; +
If you are going to use this, passing list paramenter instead of device looks like a much better option. It would indeed make things go better.
Quoted 149 lines
if (!fd_read && !fd_write) {qemu-char.h +66
-36- QLIST_FOREACH(ioh, &io_handlers, next) { + QLIST_FOREACH(ioh, list, next) {if (ioh->fd == fd) { ioh->deleted =1 ;break ; } } }else { - QLIST_FOREACH(ioh, &io_handlers, next) { + QLIST_FOREACH(ioh, list, next) {if (ioh->fd == fd) goto found; } ioh =qemu_mallocz (sizeof (IOHandlerRecord)); -QLIST_INSERT_HEAD (&io_handlers, ioh, next); +QLIST_INSERT_HEAD (list, ioh, next); found: ioh->fd = fd; ioh->fd_read_poll = fd_read_poll;@@ -998,6 +1003,19 @@ int qemu_set_fd_handler2(int fd,return 0 ; } + +/* XXX: fd_read_poll should be suppressed, but an API change is +necessary in the character devices to suppress fd_can_read(). */ +int qemu_set_fd_handler2 (int fd, +IOCanReadHandler *fd_read_poll, +IOHandler *fd_read, +IOHandler *fd_write, +void *opaque) +{ +return qemu_set_fd_handler3 (false, fd, fd_read_poll, fd_read, fd_write, + opaque); +} + int qemu_set_fd_handler(int fd, IOHandler *fd_read, IOHandler *fd_write,@@ -1242,9 +1260,52 @@ void qemu_system_powerdown_request(void)qemu_notify_event (); } -void main_loop_wait (int nonblocking) +static inline int get_ioh_fds (IOHandlerRecordList *list, +int nfds,fd_set *rfds,fd_set *wfds) {IOHandlerRecord *ioh; + QLIST_FOREACH(ioh, list, next) { +if (ioh->deleted) +continue ; +if (ioh->fd_read && + (!ioh->fd_read_poll || + ioh->fd_read_poll (ioh->opaque) !=0 )) { +FD_SET (ioh->fd, rfds); +if (ioh->fd > nfds) + nfds = ioh->fd; + } +if (ioh->fd_write) { +FD_SET (ioh->fd, wfds); +if (ioh->fd > nfds) + nfds = ioh->fd; + } + } +return nfds; +} + +static inline void call_ioh_fds (IOHandlerRecordList *list, +fd_set *rfds,fd_set *wfds) +{ +IOHandlerRecord *ioh, *pioh; + + QLIST_FOREACH_SAFE(ioh, list, next, pioh) { +if (ioh->deleted) { +QLIST_REMOVE (ioh, next); +qemu_free (ioh); +continue ; + } +if (ioh->fd_read &&FD_ISSET (ioh->fd, rfds)) { + ioh->fd_read (ioh->opaque); +if (!(ioh->fd_read_poll && ioh->fd_read_poll (ioh->opaque))) +FD_CLR (ioh->fd, rfds); + } +if (ioh->fd_write &&FD_ISSET (ioh->fd, wfds)) { + ioh->fd_write (ioh->opaque); + } + } +} +void main_loop_wait (int nonblocking) +{fd_set rfds, wfds, xfds;int ret, nfds;struct timeval tv;@@ -1260,26 +1321,13 @@ void main_loop_wait(int nonblocking)os_host_main_loop_wait (&timeout);/* poll any events */ -/* XXX: separate device handlers from system ones */ nfds =-1 ;FD_ZERO (&rfds);FD_ZERO (&wfds);FD_ZERO (&xfds); - QLIST_FOREACH(ioh, &io_handlers, next) { -if (ioh->deleted) -continue ; -if (ioh->fd_read && - (!ioh->fd_read_poll || - ioh->fd_read_poll (ioh->opaque) !=0 )) { -FD_SET (ioh->fd, &rfds); -if (ioh->fd > nfds) - nfds = ioh->fd; - } -if (ioh->fd_write) { -FD_SET (ioh->fd, &wfds); -if (ioh->fd > nfds) - nfds = ioh->fd; - } + nfds =get_ioh_fds (&system_io_handlers, nfds, &rfds, &wfds); +if (vm_running) { + nfds =get_ioh_fds (&device_io_handlers, nfds, &rfds, &wfds); } tv.tv_sec = timeout /1000 ;@@ -1291,22 +1339,9 @@ void main_loop_wait(int nonblocking) ret =select (nfds +1 , &rfds, &wfds, &xfds, &tv);qemu_mutex_lock_iothread ();if (ret >0 ) { -IOHandlerRecord *pioh; - - QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) { -if (ioh->deleted) { -QLIST_REMOVE (ioh, next); -qemu_free (ioh); -continue ; - } -if (ioh->fd_read &&FD_ISSET (ioh->fd, &rfds)) { - ioh->fd_read (ioh->opaque); -if (!(ioh->fd_read_poll && ioh->fd_read_poll (ioh->opaque))) -FD_CLR (ioh->fd, &rfds); - } -if (ioh->fd_write &&FD_ISSET (ioh->fd, &wfds)) { - ioh->fd_write (ioh->opaque); - } +call_ioh_fds (&system_io_handlers, &rfds, &wfds); +if (vm_running) { +call_ioh_fds (&device_io_handlers, &rfds, &wfds); } }
PATCH v2 2/2 tap: mark fd handler as device
In reply to Michael S. TsirkinThere's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
--- hw/vhost_net.c | 2 +- net/tap.c | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-)
hw/vhost_net.c +1 -1
@@ -139,7 +139,7 @@ int vhost_net_start(struct vhost_net *net, } net->vc->info->poll (net->vc, false); -qemu_set_fd_handler (net->backend,NULL ,NULL ,NULL ); +qemu_set_fd_handler3 (true, net->backend,NULL ,NULL ,NULL ,NULL ); file.fd = net->backend;for (file.index =0 ; file.index < net->dev.nvqs; ++file.index) { r =ioctl (net->dev.control,VHOST_NET_SET_BACKEND , &file);
net/tap.c +2 -1
@@ -71,7 +71,8 @@ static void tap_writable(void *opaque);static void tap_update_fd_handler (TAPState *s) { - qemu_set_fd_handler2(s->fd, + qemu_set_fd_handler3(true, + s->fd, s->read_poll ? tap_can_send : NULL, s->read_poll ? tap_send : NULL, s->write_poll ? tap_writable : NULL,
Signature · 1 line
1.7.3.2.91.g446ac
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 5 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Signed-off-by Michael S. Tsirkin <[email protected]>
once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
Later, Juan.
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 6 lines · Juan Quintela
Quoted 4 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Quoted 6 lines
Quoted 2 lines
Signed-off-by Michael S. Tsirkin<[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
I'm not sure I concur that this is really a problem.
Semantically, I don't think that stop has to imply that the guest memory no longer changes.
Regards,
Anthony Liguori
Quoted 2 lines
Later, Juan.
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 11 lines · Anthony Liguori
Quoted 9 lines · Juan Quintela
Quoted 5 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Signed-off-by Michael S. Tsirkin<[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
Quoted 9 lines
I'm not sure I concur that this is really a problem. Semantically, I don't think that stop has to imply that the guest memory no longer changes.
Regards,
Anthony Liguori
Quoted 1 line
Later, Juan.
Well, I do not really know about vmstop that is not for migration. For most vmstop calls are for migration. And there, the problems are very real.
First, it's not just memory. At least for network transmit, sending out packets with the same MAC from two locations is a problem. See?
For memory, it is much worse: any memory changes can either get discarded or not. This breaks consistency guarantees that guest relies upon. Imagine virtio index getting updated but content not being updated. See?
Signature · 1 line
MST
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 20 lines · Michael S. Tsirkin
Quoted 18 lines · Anthony Liguori
Quoted 6 lines · Juan Quintela
Quoted 4 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Quoted 6 lines
Quoted 2 lines
Signed-off-by Michael S. Tsirkin<[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
I'm not sure I concur that this is really a problem. Semantically, I don't think that stop has to imply that the guest memory no longer changes.
Quoted 9 lines
Quoted 7 lines
Regards,
Anthony Liguori
Quoted 2 lines
Later, Juan.
Well, I do not really know about vmstop that is not for migration.
They are separate. For instance, we don't rely on stop to pause pending disk I/O because we don't serialize pending disk I/O operations. Instead, we flush all pending I/O and rely on the fact that disk I/O requests are always submitted in the context of a vCPU operation. This assumption breaks down though with ioeventfd so we need to revisit it.
Quoted 6 lines
For most vmstop calls are for migration. And there, the problems are very real.
First, it's not just memory. At least for network transmit, sending out packets with the same MAC from two locations is a problem. See?
I agree it's a problem but I'm not sure that just marking fd handlers really helps.
Bottom halves can also trigger transmits. I think that if we put something in the network layer that just queued packets if the vm is stopped, it would be a more robust solution to the problem.
Quoted 5 lines
For memory, it is much worse: any memory changes can either get discarded or not. This breaks consistency guarantees that guest relies upon. Imagine virtio index getting updated but content not being updated. See?
If you suppress any I/O then the memory changes don't matter because the same changes will happen on the destination too.
I think this basic problem is the same as Kemari. We can either attempt to totally freeze a guest which means stopping all callbacks that are device related or we can prevent I/O from happening which should introduce enough determinism to fix the problem in practice.
Regards,
Anthony Liguori
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 33 lines · Anthony Liguori
Quoted 15 lines · Michael S. Tsirkin
Quoted 14 lines · Anthony Liguori
Quoted 9 lines · Juan Quintela
Quoted 5 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Signed-off-by Michael S. Tsirkin<[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
I'm not sure I concur that this is really a problem. Semantically, I don't think that stop has to imply that the guest memory no longer changes.
Quoted 6 lines
Quoted 5 lines
Regards,
Anthony Liguori
Quoted 1 line
Later, Juan.
Well, I do not really know about vmstop that is not for migration.
They are separate. For instance, we don't rely on stop to pause pending disk I/O because we don't serialize pending disk I/O operations. Instead, we flush all pending I/O and rely on the fact that disk I/O requests are always submitted in the context of a vCPU operation. This assumption breaks down though with ioeventfd so we need to revisit it.
Quoted 3 lines
For most vmstop calls are for migration. And there, the problems are very real.
Quoted 7 lines
Quoted 2 lines
First, it's not just memory. At least for network transmit, sending out packets with the same MAC from two locations is a problem. See?
I agree it's a problem but I'm not sure that just marking fd handlers really helps.
Bottom halves can also trigger transmits.
Are there any system ones?
Can we just stop processing them?
Quoted 3 lines
I think that if we put
something in the network layer that just queued packets if the vm is stopped, it would be a more robust solution to the problem.
Will only work for -net. The problem is for anything that can trigger activity when vm is stopped.
Quoted 7 lines
Quoted 4 lines
For memory, it is much worse: any memory changes can either get discarded or not. This breaks consistency guarantees that guest relies upon. Imagine virtio index getting updated but content not being updated. See?
If you suppress any I/O then the memory changes don't matter because the same changes will happen on the destination too.
They matter, and same changes won't happen.
Example:
virtio used index is in page 1, it can point at data in page 2. device writes into data, *then* into index. Order matters, but won't be preserved: migration assumes memory does not change after vmstop, and so it might send old values for data but new values for index. Result will be invalid data coming into guest.
On the destination guest will pick up the index and get bad (stale) data.
Quoted 8 lines
I think this basic problem is the same as Kemari. We can either attempt to totally freeze a guest which means stopping all callbacks that are device related or we can prevent I/O from happening which should introduce enough determinism to fix the problem in practice.
Regards,
Anthony Liguori
See above. IMO it's a different problem. Unlike Kemari, I don't really see any drawbacks to stop all callbacks. Do you?
Signature · 1 line
MST
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 2 lines · Michael S. Tsirkin
Are there any system ones?
There's one in qemu-char.c. Not sure it's easy to just say for the future that there can't be BHs that get delivered during vmstop.
Quoted 2 lines
Can we just stop processing them?
We ran into a lot of problems trying to do this with emulating synchronous I/O in the block layer. If we can avoid the stop-dispatching handlers approach, I think we'll have far fewer problems.
Quoted 7 lines
Quoted 4 lines
I think that if we put
something in the network layer that just queued packets if the vm is stopped, it would be a more robust solution to the problem.Will only work for -net. The problem is for anything that can trigger activity when vm is stopped.
Activity or external I/O?
My assertion is that if we can stop things from hitting the disk, escaping the network, or leaving a character device, we're solid.
Quoted 11 lines
Quoted 8 lines
Quoted 5 lines
For memory, it is much worse: any memory changes can either get discarded or not. This breaks consistency guarantees that guest relies upon. Imagine virtio index getting updated but content not being updated. See?
If you suppress any I/O then the memory changes don't matter because the same changes will happen on the destination too.
They matter, and same changes won't happen.
Example:
Quoted 7 lines
virtio used index is in page 1, it can point at data in page 2. device writes into data, *then* into index. Order matters, but won't be preserved: migration assumes memory does not change after vmstop, and so it might send old values for data but new values for index. Result will be invalid data coming into guest.
No, this scenario is invalid.
Migration copies data while the guest is live and whenever a change happens, updates the dirty bitmap (that's why cpu_physical_memory_rw matters).
Once the VM is stopped, we never return to the main loop before completing migration so nothing else gets an opportunity to run. This means when we send a page, we guarantee it won't be made dirty against until after the migration completes.
Once the migration completes, the contents of memory may change but that's okay. As long as you stop packets from being sent, if you need to resume the guest, it'll pick up where it left off.
Quoted 3 lines
On the destination guest will pick up the index and get bad (stale) data.
If you're seeing this happen with vhost, you aren't updating dirty bits correctly. AFAICT, this cannot happen with userspace device models.
Quoted 6 lines
Quoted 6 lines
I think this basic problem is the same as Kemari. We can either attempt to totally freeze a guest which means stopping all callbacks that are device related or we can prevent I/O from happening which should introduce enough determinism to fix the problem in practice.
Quoted 9 lines
Quoted 4 lines
Regards,
Anthony Liguori
See above. IMO it's a different problem. Unlike Kemari, I don't really see any drawbacks to stop all callbacks. Do you?
I think it's going to be extremely difficult to get right and keep right. A bunch of code needs to be converted to make us safe and then becomes brittle as it's very simple to change things in such a way that we're broken again.
Regards,
Anthony Liguori
Re: [Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
In reply to Anthony LiguoriQuoted 36 lines · Anthony Liguori
Quoted 35 lines · Michael S. Tsirkin
Quoted 31 lines · Anthony Liguori
Quoted 8 lines · Juan Quintela
Quoted 5 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Quoted 7 lines
Quoted 2 lines
Signed-off-by Michael S. Tsirkin<[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
I'm not sure I concur that this is really a problem. Semantically, I don't think that stop has to imply that the guest memory no longer changes.
Regards,
Anthony Liguori
Quoted 3 lines
Later, Juan.
Quoted 8 lines
Quoted 2 lines
Well, I do not really know about vmstop that is not for migration.
They are separate. For instance, we don't rely on stop to pause pending disk I/O because we don't serialize pending disk I/O operations. Instead, we flush all pending I/O and rely on the fact that disk I/O requests are always submitted in the context of a vCPU operation. This assumption breaks down though with ioeventfd so we need to revisit it.
vhost has a solution for this: register a VMChangeStateHandler function that stops ioeventfd while vm_stop(0) is in effect. Then poll to see if there is work pending.
I will add equivalent functionality to virtio-ioeventfd.
Stefan
Re: [Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 7 lines · Stefan Hajnoczi
vhost has a solution for this: register a VMChangeStateHandler function that stops ioeventfd while
vm_stop(0)is in effect. Then poll to see if there is work pending.I will add equivalent functionality to virtio-ioeventfd.
I still think that stopping this at the net/block layer is going to be a lot more robust in the long term. All net/block traffic flows through a single set of interfaces whereas getting the devices to completely stop themselves requires touching every device and making sure that noone adds back vmstop-unfriendly behavior down the road.
Regards,
Anthony Liguori
Quoted 2 lines
Stefan
Re: [Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 15 lines · Anthony Liguori
Quoted 6 lines · Stefan Hajnoczi
vhost has a solution for this: register a VMChangeStateHandler function that stops ioeventfd while
vm_stop(0)is in effect. Then poll to see if there is work pending.I will add equivalent functionality to virtio-ioeventfd.
I still think that stopping this at the net/block layer is going to be a lot more robust in the long term.
All net/block traffic flows
through a single set of interfaces whereas getting the devices to completely stop themselves requires touching every device and making sure that noone adds back vmstop-unfriendly behavior down the road.
Quoted 3 lines
Regards,
Anthony Liguori
So I'm not sure I understand what is proposed here. Care posting a patch?
Signature · 1 line
MST
Re: [Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
Quoted 3 lines · Michael S. Tsirkin
So I'm not sure I understand what is proposed here. Care posting a patch?
I *think* just adding:
if (vm_running == 0) {
return qemu_net_queue_append(queue, sender, flags, data, size, NULL);
}To qemu_net_queue_send() along with a state notifier to kick the queue on start would do the trick.
Regards,
Anthony Liguori
[Qemu-devel] Re: [PATCHv2 2/2] tap: mark fd handler as device
In reply to Juan QuintelaQuoted 5 lines · Juan Quintela
Quoted 4 lines · Michael S. Tsirkin
There's no reason for tap to run when VM is stopped. If we let it, it confuses the bridge on TX and corrupts DMA memory on RX.
Quoted 7 lines
Quoted 1 line
Signed-off-by Michael S. Tsirkin <[email protected]>once here, what handlers make sense to run while stopped? /me can think of the normal console, non live migration, loadvm and not much more. Perhaps it is easier to just move the other way around?
Later, Juan.
vnc? SDL?
Yes, more devices need to be stopped than not, but I tread carefully to avoid breaking existing functionality. If you could solve it for all devices in one swoop, that'd be great. I'm not up to it.
Signature · 1 line
MST