blob: 4228635d18806dc419677ccbde54c7b067baf831 [file] [log] [blame]
aliguori5bb79102008-10-13 03:12:02 +00001/*
2 * QEMU live migration
3 *
4 * Copyright IBM, Corp. 2008
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
Paolo Bonzini6b620ca2012-01-13 17:44:23 +010012 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
aliguori5bb79102008-10-13 03:12:02 +000014 */
15
Peter Maydell1393a482016-01-26 18:16:54 +000016#include "qemu/osdep.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020017#include "qemu/cutils.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010018#include "qemu/error-report.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020019#include "qemu/main-loop.h"
Juan Quintela795c40b2017-04-06 12:00:28 +020020#include "migration/blocker.h"
Juan Quintelaf4dbe1b2017-04-05 15:54:10 +020021#include "exec.h"
Juan Quintela7fcac4a2017-04-05 15:58:29 +020022#include "fd.h"
Juan Quintela61e8b142017-04-05 17:40:11 +020023#include "socket.h"
Markus Armbruster54d31232019-08-12 07:23:59 +020024#include "sysemu/runstate.h"
Markus Armbruster46517dd2019-08-12 07:23:57 +020025#include "sysemu/sysemu.h"
Claudio Fontanab0c3cf92020-06-29 11:35:03 +020026#include "sysemu/cpu-throttle.h"
Juan Quintelae1a3ece2017-04-17 20:32:36 +020027#include "rdma.h"
Juan Quintela7b1e1a22017-04-17 20:26:27 +020028#include "ram.h"
Juan Quintela84a899d2017-04-24 18:53:30 +020029#include "migration/global_state.h"
Juan Quintelac4b63b72017-04-24 19:02:44 +020030#include "migration/misc.h"
Juan Quintela6666c962017-04-24 20:07:27 +020031#include "migration.h"
Juan Quintela20a519a2017-04-20 14:48:46 +020032#include "savevm.h"
Juan Quintela40014d82017-04-17 19:34:36 +020033#include "qemu-file-channel.h"
Juan Quintela08a0aee2017-04-20 18:52:18 +020034#include "qemu-file.h"
Juan Quintela987772d2017-04-17 19:02:59 +020035#include "migration/vmstate.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010036#include "block/block.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010037#include "qapi/error.h"
Juan Quintela9aca82b2019-02-27 11:51:27 +010038#include "qapi/clone-visitor.h"
Max Reitz31e4c352020-08-20 17:07:23 +020039#include "qapi/qapi-visit-migration.h"
Juan Quintela9aca82b2019-02-27 11:51:27 +010040#include "qapi/qapi-visit-sockets.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010041#include "qapi/qapi-commands-migration.h"
42#include "qapi/qapi-events-migration.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010043#include "qapi/qmp/qerror.h"
Markus Armbruster15280c32018-02-01 12:18:36 +010044#include "qapi/qmp/qnull.h"
Paolo Bonziniab28bd22015-07-09 08:55:38 +020045#include "qemu/rcu.h"
Juan Quintela2c9e6fe2017-04-21 14:31:22 +020046#include "block.h"
Juan Quintelabe07b0a2017-04-20 13:12:24 +020047#include "postcopy-ram.h"
Juan Quintela766bd172012-07-23 05:45:29 +020048#include "qemu/thread.h"
Kazuya Saitoc09e5bb2013-02-22 17:36:19 +010049#include "trace.h"
Juan Quintela51180422017-04-24 20:50:19 +020050#include "exec/target_page.h"
Daniel P. Berrange61b67d42016-04-27 11:05:01 +010051#include "io/channel-buffer.h"
zhanghailiang35a6ed42016-10-27 14:42:52 +080052#include "migration/colo.h"
Peter Xu4ffdb332017-06-27 12:10:18 +080053#include "hw/boards.h"
Markus Armbrustera27bd6c2019-08-12 07:23:51 +020054#include "hw/qdev-properties.h"
Eduardo Habkostce35e222020-12-11 17:05:12 -050055#include "hw/qdev-properties-system.h"
Peter Xu9d18af92017-06-27 12:10:19 +080056#include "monitor/monitor.h"
Dr. David Alan Gilbert50510ea2019-02-27 13:24:05 +000057#include "net/announce.h"
Jens Freimannc7e0acd2019-10-29 12:49:02 +010058#include "qemu/queue.h"
Juan Quintelad32ca5a2020-01-22 16:16:07 +010059#include "multifd.h"
Lukas Straubb5eea992020-12-28 16:08:52 +010060#include "qemu/yank.h"
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +030061#include "sysemu/cpus.h"
aliguori065e2812008-11-11 16:46:33 +000062
Laurent Vivier7590a2a2020-09-21 16:49:57 +020063#define MAX_THROTTLE (128 << 20) /* Migration transfer speed throttling */
aliguori5bb79102008-10-13 03:12:02 +000064
Juan Quintela5b4e1eb2012-12-19 10:40:48 +010065/* Amount of time to allocate to each "chunk" of bandwidth-throttled
66 * data. */
67#define BUFFER_DELAY 100
68#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
69
Ashijeet Acharya2ff30252016-09-15 21:50:28 +053070/* Time in milliseconds we are allowed to stop the source,
71 * for sending the last part */
72#define DEFAULT_MIGRATE_SET_DOWNTIME 300
73
Daniel Henrique Barboza87c9cc12017-02-22 12:17:29 -030074/* Maximum migrate downtime set to 2000 seconds */
75#define MAX_MIGRATE_DOWNTIME_SECONDS 2000
76#define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000)
77
Liang Li8706d2d2015-03-23 16:32:17 +080078/* Default compression thread count */
79#define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8
Liang Li3fcb38c2015-03-23 16:32:18 +080080/* Default decompression thread count, usually decompression is at
81 * least 4 times as fast as compression.*/
82#define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2
Liang Li8706d2d2015-03-23 16:32:17 +080083/*0: means nocompress, 1: best speed, ... 9: best compress ratio */
84#define DEFAULT_MIGRATE_COMPRESS_LEVEL 1
Jason J. Herne1626fee2015-09-08 13:12:34 -040085/* Define default autoconverge cpu throttle migration parameters */
Keqian Zhudc14a472020-02-24 10:31:42 +080086#define DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD 50
Jason J. Herned85a31d2016-04-21 14:07:18 -040087#define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20
88#define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10
Li Qiang4cbc9c72018-08-01 06:00:20 -070089#define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99
Liang Li8706d2d2015-03-23 16:32:17 +080090
Orit Wasserman17ad9b32012-08-06 21:42:53 +030091/* Migration XBZRLE default cache size */
Juan Quintela73af8dd2017-10-05 21:30:10 +020092#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
Orit Wasserman17ad9b32012-08-06 21:42:53 +030093
Zhang Chen131b2152018-09-03 12:38:45 +080094/* The delay time (in ms) between two COLO checkpoints */
95#define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100)
Juan Quintela4075fb12016-01-15 08:56:17 +010096#define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2
Juan Quintela96eef042019-01-16 10:35:55 +010097#define DEFAULT_MIGRATE_MULTIFD_COMPRESSION MULTIFD_COMPRESSION_NONE
Juan Quintela9004db42020-01-23 17:08:52 +010098/* 0: means nocompress, 1: best speed, ... 9: best compress ratio */
99#define DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL 1
Juan Quintela6a9ad152020-01-23 17:41:36 +0100100/* 0: means nocompress, 1: best speed, ... 20: best compress ratio */
101#define DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL 1
zhanghailiang68b53592016-10-27 14:43:01 +0800102
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +0100103/* Background transfer rate for postcopy, 0 means unlimited, note
104 * that page requests can still exceed this limit.
105 */
106#define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0
107
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +0000108/*
109 * Parameters for self_announce_delay giving a stream of RARP/ARP
110 * packets after migration.
111 */
112#define DEFAULT_MIGRATE_ANNOUNCE_INITIAL 50
113#define DEFAULT_MIGRATE_ANNOUNCE_MAX 550
114#define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS 5
115#define DEFAULT_MIGRATE_ANNOUNCE_STEP 100
116
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100117static NotifierList migration_state_notifiers =
118 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
119
Juan Quintelada6f1792017-04-24 17:37:14 +0200120/* Messages sent on the return path from destination to source */
121enum mig_rp_message_type {
122 MIG_RP_MSG_INVALID = 0, /* Must be 0 */
123 MIG_RP_MSG_SHUT, /* sibling will not send any more RP messages */
124 MIG_RP_MSG_PONG, /* Response to a PING; data (seq: be32 ) */
125
126 MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */
127 MIG_RP_MSG_REQ_PAGES, /* data (start: be64, len: be32) */
Peter Xua335deb2018-05-02 18:47:28 +0800128 MIG_RP_MSG_RECV_BITMAP, /* send recved_bitmap back to source */
Peter Xu13955b82018-05-02 18:47:30 +0800129 MIG_RP_MSG_RESUME_ACK, /* tell source that we are ready to resume */
Juan Quintelada6f1792017-04-24 17:37:14 +0200130
131 MIG_RP_MSG_MAX
132};
133
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +0300134/* Migration capabilities set */
135struct MigrateCapsSet {
136 int size; /* Capability set size */
137 MigrationCapability caps[]; /* Variadic array of capabilities */
138};
139typedef struct MigrateCapsSet MigrateCapsSet;
140
141/* Define and initialize MigrateCapsSet */
142#define INITIALIZE_MIGRATE_CAPS_SET(_name, ...) \
143 MigrateCapsSet _name = { \
144 .size = sizeof((int []) { __VA_ARGS__ }) / sizeof(int), \
145 .caps = { __VA_ARGS__ } \
146 }
147
148/* Background-snapshot compatibility check list */
149static const
150INITIALIZE_MIGRATE_CAPS_SET(check_caps_background_snapshot,
151 MIGRATION_CAPABILITY_POSTCOPY_RAM,
152 MIGRATION_CAPABILITY_DIRTY_BITMAPS,
153 MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME,
154 MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE,
155 MIGRATION_CAPABILITY_RETURN_PATH,
156 MIGRATION_CAPABILITY_MULTIFD,
157 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER,
158 MIGRATION_CAPABILITY_AUTO_CONVERGE,
159 MIGRATION_CAPABILITY_RELEASE_RAM,
160 MIGRATION_CAPABILITY_RDMA_PIN_ALL,
161 MIGRATION_CAPABILITY_COMPRESS,
162 MIGRATION_CAPABILITY_XBZRLE,
163 MIGRATION_CAPABILITY_X_COLO,
164 MIGRATION_CAPABILITY_VALIDATE_UUID);
165
Juan Quintela17549e82011-10-05 13:50:43 +0200166/* When we add fault tolerance, we could have several
167 migrations at once. For now we don't need to add
168 dynamic creation of migration */
169
Peter Xue5cb7e72017-06-27 12:10:13 +0800170static MigrationState *current_migration;
Peter Xue1b1b1b2018-05-02 18:47:35 +0800171static MigrationIncomingState *current_incoming;
Peter Xue5cb7e72017-06-27 12:10:13 +0800172
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +0000173static GSList *migration_blockers;
174
Peter Xu8b0b29d2017-07-18 11:39:06 +0800175static bool migration_object_check(MigrationState *ms, Error **errp);
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +0100176static int migration_maybe_pause(MigrationState *s,
177 int *current_active_state,
178 int new_state);
Dr. David Alan Gilbert892ae712019-02-27 16:49:00 +0000179static void migrate_fd_cancel(MigrationState *s);
Peter Xu8b0b29d2017-07-18 11:39:06 +0800180
Peter Xu8f8bfff2020-10-21 17:27:18 -0400181static gint page_request_addr_cmp(gconstpointer ap, gconstpointer bp)
182{
183 uintptr_t a = (uintptr_t) ap, b = (uintptr_t) bp;
184
185 return (a > b) - (a < b);
186}
187
Peter Xue5cb7e72017-06-27 12:10:13 +0800188void migration_object_init(void)
189{
Peter Xu8b0b29d2017-07-18 11:39:06 +0800190 Error *err = NULL;
Peter Xu4ffdb332017-06-27 12:10:18 +0800191
Peter Xue5cb7e72017-06-27 12:10:13 +0800192 /* This can only be called once. */
193 assert(!current_migration);
194 current_migration = MIGRATION_OBJ(object_new(TYPE_MIGRATION));
Peter Xu4ffdb332017-06-27 12:10:18 +0800195
Peter Xue1b1b1b2018-05-02 18:47:35 +0800196 /*
197 * Init the migrate incoming object as well no matter whether
198 * we'll use it or not.
199 */
200 assert(!current_incoming);
201 current_incoming = g_new0(MigrationIncomingState, 1);
202 current_incoming->state = MIGRATION_STATUS_NONE;
203 current_incoming->postcopy_remote_fds =
204 g_array_new(FALSE, TRUE, sizeof(struct PostCopyFD));
205 qemu_mutex_init(&current_incoming->rp_mutex);
206 qemu_event_init(&current_incoming->main_thread_load_event, false);
207 qemu_sem_init(&current_incoming->postcopy_pause_sem_dst, 0);
208 qemu_sem_init(&current_incoming->postcopy_pause_sem_fault, 0);
Peter Xu8f8bfff2020-10-21 17:27:18 -0400209 qemu_mutex_init(&current_incoming->page_request_mutex);
210 current_incoming->page_requested = g_tree_new(page_request_addr_cmp);
Peter Xue1b1b1b2018-05-02 18:47:35 +0800211
Peter Xu8b0b29d2017-07-18 11:39:06 +0800212 if (!migration_object_check(current_migration, &err)) {
213 error_report_err(err);
214 exit(1);
215 }
Paolo Bonzinie0d17df2020-10-21 05:25:58 -0400216
217 blk_mig_init();
218 ram_mig_init();
219 dirty_bitmap_mig_init();
Peter Xue5cb7e72017-06-27 12:10:13 +0800220}
221
David Hildenbrandc7c0e722021-04-29 13:27:02 +0200222void migration_cancel(void)
223{
224 migrate_fd_cancel(current_migration);
225}
226
Dr. David Alan Gilbert892ae712019-02-27 16:49:00 +0000227void migration_shutdown(void)
Vladimir Sementsov-Ogievskiy1f895602017-12-28 12:16:16 +0300228{
Dr. David Alan Gilbert892ae712019-02-27 16:49:00 +0000229 /*
230 * Cancel the current migration - that will (eventually)
231 * stop the migration using this structure
232 */
David Hildenbrandc7c0e722021-04-29 13:27:02 +0200233 migration_cancel();
Vladimir Sementsov-Ogievskiy1f895602017-12-28 12:16:16 +0300234 object_unref(OBJECT(current_migration));
Vladimir Sementsov-Ogievskiy1499ab02020-07-27 22:42:31 +0300235
236 /*
237 * Cancel outgoing migration of dirty bitmaps. It should
238 * at least unref used block nodes.
239 */
240 dirty_bitmap_mig_cancel_outgoing();
241
242 /*
243 * Cancel incoming migration of dirty bitmaps. Dirty bitmaps
244 * are non-critical data, and their loss never considered as
245 * something serious.
246 */
247 dirty_bitmap_mig_cancel_incoming();
Vladimir Sementsov-Ogievskiy1f895602017-12-28 12:16:16 +0300248}
249
Dr. David Alan Gilbertbca78562015-05-21 13:24:14 +0100250/* For outgoing */
Juan Quintela859bc752012-08-13 09:42:49 +0200251MigrationState *migrate_get_current(void)
Juan Quintela17549e82011-10-05 13:50:43 +0200252{
Peter Xue5cb7e72017-06-27 12:10:13 +0800253 /* This can only be called after the object created. */
254 assert(current_migration);
255 return current_migration;
Juan Quintela17549e82011-10-05 13:50:43 +0200256}
257
Dr. David Alan Gilbertbca78562015-05-21 13:24:14 +0100258MigrationIncomingState *migration_incoming_get_current(void)
259{
Peter Xue1b1b1b2018-05-02 18:47:35 +0800260 assert(current_incoming);
261 return current_incoming;
Dr. David Alan Gilbertbca78562015-05-21 13:24:14 +0100262}
263
264void migration_incoming_state_destroy(void)
265{
Juan Quintelab4b076d2017-01-23 22:32:06 +0100266 struct MigrationIncomingState *mis = migration_incoming_get_current();
267
Peter Xu34826552017-05-19 14:43:29 +0800268 if (mis->to_src_file) {
Peter Xu660819b2017-05-19 14:43:30 +0800269 /* Tell source that we are done */
270 migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
Peter Xu34826552017-05-19 14:43:29 +0800271 qemu_fclose(mis->to_src_file);
272 mis->to_src_file = NULL;
273 }
274
Peter Xu660819b2017-05-19 14:43:30 +0800275 if (mis->from_src_file) {
276 qemu_fclose(mis->from_src_file);
277 mis->from_src_file = NULL;
278 }
Dr. David Alan Gilbert00fa4fc2018-03-12 17:21:04 +0000279 if (mis->postcopy_remote_fds) {
280 g_array_free(mis->postcopy_remote_fds, TRUE);
281 mis->postcopy_remote_fds = NULL;
282 }
Dr. David Alan Gilbert1df6ddb2021-04-21 12:28:32 +0100283 if (mis->transport_cleanup) {
284 mis->transport_cleanup(mis->transport_data);
285 }
Peter Xu660819b2017-05-19 14:43:30 +0800286
Dr. David Alan Gilbert1783c002020-09-28 15:48:30 +0100287 qemu_event_reset(&mis->main_thread_load_event);
288
Peter Xu8f8bfff2020-10-21 17:27:18 -0400289 if (mis->page_requested) {
290 g_tree_destroy(mis->page_requested);
291 mis->page_requested = NULL;
292 }
293
Juan Quintela9aca82b2019-02-27 11:51:27 +0100294 if (mis->socket_address_list) {
295 qapi_free_SocketAddressList(mis->socket_address_list);
296 mis->socket_address_list = NULL;
297 }
Lukas Straubb5eea992020-12-28 16:08:52 +0100298
299 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
Dr. David Alan Gilbertbca78562015-05-21 13:24:14 +0100300}
301
Juan Quintelab05dc722015-07-07 14:44:05 +0200302static void migrate_generate_event(int new_state)
303{
304 if (migrate_use_events()) {
Peter Xu3ab72382018-08-15 21:37:37 +0800305 qapi_event_send_migration(new_state);
Juan Quintelab05dc722015-07-07 14:44:05 +0200306 }
307}
308
Dr. David Alan Gilbert0f073f42018-04-16 18:09:30 +0100309static bool migrate_late_block_activate(void)
310{
311 MigrationState *s;
312
313 s = migrate_get_current();
314
315 return s->enabled_capabilities[
316 MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE];
317}
318
Dr. David Alan Gilbertadde2202015-02-19 11:40:27 +0000319/*
Juan Quintelada6f1792017-04-24 17:37:14 +0200320 * Send a message on the return channel back to the source
321 * of the migration.
322 */
Peter Xud6208e32018-02-08 18:31:12 +0800323static int migrate_send_rp_message(MigrationIncomingState *mis,
324 enum mig_rp_message_type message_type,
325 uint16_t len, void *data)
Juan Quintelada6f1792017-04-24 17:37:14 +0200326{
Peter Xud6208e32018-02-08 18:31:12 +0800327 int ret = 0;
328
Juan Quintelada6f1792017-04-24 17:37:14 +0200329 trace_migrate_send_rp_message((int)message_type, len);
Mahmoud Mandour37396952021-03-11 05:15:35 +0200330 QEMU_LOCK_GUARD(&mis->rp_mutex);
Peter Xud6208e32018-02-08 18:31:12 +0800331
332 /*
333 * It's possible that the file handle got lost due to network
334 * failures.
335 */
336 if (!mis->to_src_file) {
337 ret = -EIO;
Mahmoud Mandour37396952021-03-11 05:15:35 +0200338 return ret;
Peter Xud6208e32018-02-08 18:31:12 +0800339 }
340
Juan Quintelada6f1792017-04-24 17:37:14 +0200341 qemu_put_be16(mis->to_src_file, (unsigned int)message_type);
342 qemu_put_be16(mis->to_src_file, len);
343 qemu_put_buffer(mis->to_src_file, data, len);
344 qemu_fflush(mis->to_src_file);
Peter Xud6208e32018-02-08 18:31:12 +0800345
346 /* It's possible that qemu file got error during sending */
347 ret = qemu_file_get_error(mis->to_src_file);
348
Peter Xud6208e32018-02-08 18:31:12 +0800349 return ret;
Juan Quintelada6f1792017-04-24 17:37:14 +0200350}
351
Peter Xu2e2bce12020-09-08 16:30:18 -0400352/* Request one page from the source VM at the given start address.
353 * rb: the RAMBlock to request the page in
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000354 * Start: Address offset within the RB
355 * Len: Length in bytes required - must be a multiple of pagesize
356 */
Peter Xu7a267fc2020-10-21 17:27:17 -0400357int migrate_send_rp_message_req_pages(MigrationIncomingState *mis,
358 RAMBlock *rb, ram_addr_t start)
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000359{
Stefan Weilcb8d4c82016-03-23 15:59:57 +0100360 uint8_t bufc[12 + 1 + 255]; /* start (8), len (4), rbname up to 256 */
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000361 size_t msglen = 12; /* start + len */
Peter Xu2e2bce12020-09-08 16:30:18 -0400362 size_t len = qemu_ram_pagesize(rb);
Peter Xud6208e32018-02-08 18:31:12 +0800363 enum mig_rp_message_type msg_type;
Peter Xu2e2bce12020-09-08 16:30:18 -0400364 const char *rbname;
365 int rbname_len;
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000366
367 *(uint64_t *)bufc = cpu_to_be64((uint64_t)start);
368 *(uint32_t *)(bufc + 8) = cpu_to_be32((uint32_t)len);
369
Peter Xu2e2bce12020-09-08 16:30:18 -0400370 /*
371 * We maintain the last ramblock that we requested for page. Note that we
372 * don't need locking because this function will only be called within the
373 * postcopy ram fault thread.
374 */
375 if (rb != mis->last_rb) {
376 mis->last_rb = rb;
377
378 rbname = qemu_ram_get_idstr(rb);
379 rbname_len = strlen(rbname);
380
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000381 assert(rbname_len < 256);
382
383 bufc[msglen++] = rbname_len;
384 memcpy(bufc + msglen, rbname, rbname_len);
385 msglen += rbname_len;
Peter Xud6208e32018-02-08 18:31:12 +0800386 msg_type = MIG_RP_MSG_REQ_PAGES_ID;
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000387 } else {
Peter Xud6208e32018-02-08 18:31:12 +0800388 msg_type = MIG_RP_MSG_REQ_PAGES;
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000389 }
Peter Xud6208e32018-02-08 18:31:12 +0800390
391 return migrate_send_rp_message(mis, msg_type, msglen, bufc);
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +0000392}
393
Peter Xu7a267fc2020-10-21 17:27:17 -0400394int migrate_send_rp_req_pages(MigrationIncomingState *mis,
Peter Xu8f8bfff2020-10-21 17:27:18 -0400395 RAMBlock *rb, ram_addr_t start, uint64_t haddr)
Peter Xu7a267fc2020-10-21 17:27:17 -0400396{
Peter Xu8f8bfff2020-10-21 17:27:18 -0400397 void *aligned = (void *)(uintptr_t)(haddr & (-qemu_ram_pagesize(rb)));
Chen Quna2429282020-11-11 22:22:03 +0800398 bool received = false;
Peter Xu8f8bfff2020-10-21 17:27:18 -0400399
400 WITH_QEMU_LOCK_GUARD(&mis->page_request_mutex) {
401 received = ramblock_recv_bitmap_test_byte_offset(rb, start);
402 if (!received && !g_tree_lookup(mis->page_requested, aligned)) {
403 /*
404 * The page has not been received, and it's not yet in the page
405 * request list. Queue it. Set the value of element to 1, so that
406 * things like g_tree_lookup() will return TRUE (1) when found.
407 */
408 g_tree_insert(mis->page_requested, aligned, (gpointer)1);
409 mis->page_requested_count++;
410 trace_postcopy_page_req_add(aligned, mis->page_requested_count);
411 }
412 }
413
414 /*
415 * If the page is there, skip sending the message. We don't even need the
416 * lock because as long as the page arrived, it'll be there forever.
417 */
418 if (received) {
419 return 0;
420 }
421
Peter Xu7a267fc2020-10-21 17:27:17 -0400422 return migrate_send_rp_message_req_pages(mis, rb, start);
423}
424
Zhang Chenaad555c2018-09-03 12:38:47 +0800425static bool migration_colo_enabled;
426bool migration_incoming_colo_enabled(void)
427{
428 return migration_colo_enabled;
429}
430
431void migration_incoming_disable_colo(void)
432{
David Hildenbrand18b1d3c2020-06-26 09:22:36 +0200433 ram_block_discard_disable(false);
Zhang Chenaad555c2018-09-03 12:38:47 +0800434 migration_colo_enabled = false;
435}
436
David Hildenbrand18b1d3c2020-06-26 09:22:36 +0200437int migration_incoming_enable_colo(void)
Zhang Chenaad555c2018-09-03 12:38:47 +0800438{
David Hildenbrand18b1d3c2020-06-26 09:22:36 +0200439 if (ram_block_discard_disable(true)) {
440 error_report("COLO: cannot disable RAM discard");
441 return -EBUSY;
442 }
Zhang Chenaad555c2018-09-03 12:38:47 +0800443 migration_colo_enabled = true;
David Hildenbrand18b1d3c2020-06-26 09:22:36 +0200444 return 0;
Zhang Chenaad555c2018-09-03 12:38:47 +0800445}
446
Juan Quintela9aca82b2019-02-27 11:51:27 +0100447void migrate_add_address(SocketAddress *address)
448{
449 MigrationIncomingState *mis = migration_incoming_get_current();
Juan Quintela9aca82b2019-02-27 11:51:27 +0100450
Eric Blake54aa3de2020-11-12 19:13:37 -0600451 QAPI_LIST_PREPEND(mis->socket_address_list,
452 QAPI_CLONE(SocketAddress, address));
Juan Quintela9aca82b2019-02-27 11:51:27 +0100453}
454
Paolo Bonzinie69d50d2020-10-27 04:22:57 -0400455static void qemu_start_incoming_migration(const char *uri, Error **errp)
aliguori5bb79102008-10-13 03:12:02 +0000456{
Longpeng(Mike)d658f652020-08-06 15:40:29 +0800457 const char *p = NULL;
aliguori34c9dd82008-10-13 03:14:31 +0000458
Lukas Straubb5eea992020-12-28 16:08:52 +0100459 if (!yank_register_instance(MIGRATION_YANK_INSTANCE, errp)) {
460 return;
461 }
462
Peter Xu3ab72382018-08-15 21:37:37 +0800463 qapi_event_send_migration(MIGRATION_STATUS_SETUP);
Paolo Bonzinie69d50d2020-10-27 04:22:57 -0400464 if (strstart(uri, "tcp:", &p) ||
465 strstart(uri, "unix:", NULL) ||
466 strstart(uri, "vsock:", NULL)) {
Longpeng(Mike)d658f652020-08-06 15:40:29 +0800467 socket_start_incoming_migration(p ? p : uri, errp);
Michael R. Hines2da776d2013-07-22 10:01:54 -0400468#ifdef CONFIG_RDMA
Dr. David Alan Gilbertadde2202015-02-19 11:40:27 +0000469 } else if (strstart(uri, "rdma:", &p)) {
Michael R. Hines2da776d2013-07-22 10:01:54 -0400470 rdma_start_incoming_migration(p, errp);
471#endif
Dr. David Alan Gilbertadde2202015-02-19 11:40:27 +0000472 } else if (strstart(uri, "exec:", &p)) {
Paolo Bonzini43eaae22012-10-02 18:21:18 +0200473 exec_start_incoming_migration(p, errp);
Dr. David Alan Gilbertadde2202015-02-19 11:40:27 +0000474 } else if (strstart(uri, "fd:", &p)) {
Paolo Bonzini43eaae22012-10-02 18:21:18 +0200475 fd_start_incoming_migration(p, errp);
Dr. David Alan Gilbertadde2202015-02-19 11:40:27 +0000476 } else {
Lukas Straubb5eea992020-12-28 16:08:52 +0100477 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
Markus Armbruster312fd5f2013-02-08 21:22:16 +0100478 error_setg(errp, "unknown migration protocol: %s", uri);
Juan Quintela8ca5e802010-06-09 14:10:54 +0200479 }
aliguori5bb79102008-10-13 03:12:02 +0000480}
481
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300482static void process_incoming_migration_bh(void *opaque)
483{
484 Error *local_err = NULL;
485 MigrationIncomingState *mis = opaque;
486
Dr. David Alan Gilbert0f073f42018-04-16 18:09:30 +0100487 /* If capability late_block_activate is set:
488 * Only fire up the block code now if we're going to restart the
489 * VM, else 'cont' will do it.
490 * This causes file locking to happen; so we don't want it to happen
491 * unless we really are starting the VM.
492 */
493 if (!migrate_late_block_activate() ||
494 (autostart && (!global_state_received() ||
495 global_state_get_runstate() == RUN_STATE_RUNNING))) {
496 /* Make sure all file formats flush their mutable metadata.
497 * If we get an error here, just don't restart the VM yet. */
498 bdrv_invalidate_cache_all(&local_err);
499 if (local_err) {
500 error_report_err(local_err);
501 local_err = NULL;
502 autostart = false;
503 }
Kevin Wolfd35ff5e2017-04-04 17:29:03 +0200504 }
505
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300506 /*
507 * This must happen after all error conditions are dealt with and
508 * we're sure the VM is going to be running on this host.
509 */
Dr. David Alan Gilbert76595052019-02-27 13:24:08 +0000510 qemu_announce_self(&mis->announce_timer, migrate_announce_params());
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300511
Juan Quintelaf986c3d2016-01-14 16:52:55 +0100512 if (multifd_load_cleanup(&local_err) != 0) {
513 error_report_err(local_err);
514 autostart = false;
515 }
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300516 /* If global state section was not received or we are in running
517 state, we need to obey autostart. Any other state is set with
518 runstate_set. */
519
Vladimir Sementsov-Ogievskiyb35ebdf2018-03-13 15:34:01 -0400520 dirty_bitmap_mig_before_vm_start();
521
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300522 if (!global_state_received() ||
523 global_state_get_runstate() == RUN_STATE_RUNNING) {
524 if (autostart) {
525 vm_start();
526 } else {
527 runstate_set(RUN_STATE_PAUSED);
528 }
Zhang Chendb009722019-03-03 22:50:17 +0800529 } else if (migration_incoming_colo_enabled()) {
530 migration_incoming_disable_colo();
531 vm_start();
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300532 } else {
533 runstate_set(global_state_get_runstate());
534 }
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300535 /*
536 * This must happen after any state changes since as soon as an external
537 * observer sees this event they might start to prod at the VM assuming
538 * it's ready to use.
539 */
540 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
541 MIGRATION_STATUS_COMPLETED);
542 qemu_bh_delete(mis->bh);
543 migration_incoming_state_destroy();
544}
545
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200546static void process_incoming_migration_co(void *opaque)
Juan Quintela511c0232010-06-09 14:10:55 +0200547{
Juan Quintelab4b076d2017-01-23 22:32:06 +0100548 MigrationIncomingState *mis = migration_incoming_get_current();
Dr. David Alan Gilberte9bef232015-11-05 18:11:21 +0000549 PostcopyState ps;
Paolo Bonzini1c12e1f2012-08-07 10:51:51 +0200550 int ret;
Zhang Chen8e48ac92018-09-03 12:38:46 +0800551 Error *local_err = NULL;
Paolo Bonzini1c12e1f2012-08-07 10:51:51 +0200552
Juan Quintela4f0fae72017-07-24 12:42:02 +0200553 assert(mis->from_src_file);
Lidong Chen92370982018-08-06 21:29:35 +0800554 mis->migration_incoming_co = qemu_coroutine_self();
Dr. David Alan Gilbert67f11b52017-02-24 18:28:34 +0000555 mis->largest_page_size = qemu_ram_pagesize_largest();
Dr. David Alan Gilbert093e3c42015-11-05 18:10:52 +0000556 postcopy_state_set(POSTCOPY_INCOMING_NONE);
zhanghailiang93d7af62015-12-16 11:47:34 +0000557 migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
558 MIGRATION_STATUS_ACTIVE);
Juan Quintela4f0fae72017-07-24 12:42:02 +0200559 ret = qemu_loadvm_state(mis->from_src_file);
Dr. David Alan Gilbertbca78562015-05-21 13:24:14 +0100560
Dr. David Alan Gilberte9bef232015-11-05 18:11:21 +0000561 ps = postcopy_state_get();
562 trace_process_incoming_migration_co_end(ret, ps);
563 if (ps != POSTCOPY_INCOMING_NONE) {
564 if (ps == POSTCOPY_INCOMING_ADVISE) {
565 /*
566 * Where a migration had postcopy enabled (and thus went to advise)
567 * but managed to complete within the precopy period, we can use
568 * the normal exit.
569 */
570 postcopy_ram_incoming_cleanup(mis);
571 } else if (ret >= 0) {
572 /*
573 * Postcopy was started, cleanup should happen at the end of the
574 * postcopy thread.
575 */
576 trace_process_incoming_migration_co_postcopy_end_main();
577 return;
578 }
579 /* Else if something went wrong then just fall out of the normal exit */
580 }
581
zhanghailiang25d0c162016-10-27 14:42:55 +0800582 /* we get COLO info, and know if we are in COLO mode */
Zhang Chenaad555c2018-09-03 12:38:47 +0800583 if (!ret && migration_incoming_colo_enabled()) {
Zhang Chen8e48ac92018-09-03 12:38:46 +0800584 /* Make sure all file formats flush their mutable metadata */
585 bdrv_invalidate_cache_all(&local_err);
586 if (local_err) {
Zhang Chen8e48ac92018-09-03 12:38:46 +0800587 error_report_err(local_err);
Fei Li6d99c2d2019-01-13 22:08:49 +0800588 goto fail;
Zhang Chen8e48ac92018-09-03 12:38:46 +0800589 }
590
zhanghailiang25d0c162016-10-27 14:42:55 +0800591 qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming",
592 colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);
593 mis->have_colo_incoming_thread = true;
594 qemu_coroutine_yield();
595
596 /* Wait checkpoint incoming thread exit before free resource */
597 qemu_thread_join(&mis->colo_incoming_thread);
Zhang Chen13af18f2018-09-03 12:38:48 +0800598 /* We hold the global iothread lock, so it is safe here */
599 colo_release_ram_cache();
zhanghailiang25d0c162016-10-27 14:42:55 +0800600 }
601
Paolo Bonzini1c12e1f2012-08-07 10:51:51 +0200602 if (ret < 0) {
Peter Lievendb80fac2014-06-10 11:29:16 +0200603 error_report("load of migration failed: %s", strerror(-ret));
Fei Li6d99c2d2019-01-13 22:08:49 +0800604 goto fail;
Juan Quintela511c0232010-06-09 14:10:55 +0200605 }
Denis V. Lunev0aa6aef2016-02-24 11:53:38 +0300606 mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);
607 qemu_bh_schedule(mis->bh);
Lidong Chen92370982018-08-06 21:29:35 +0800608 mis->migration_incoming_co = NULL;
Fei Li6d99c2d2019-01-13 22:08:49 +0800609 return;
610fail:
611 local_err = NULL;
612 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
613 MIGRATION_STATUS_FAILED);
614 qemu_fclose(mis->from_src_file);
615 if (multifd_load_cleanup(&local_err) != 0) {
616 error_report_err(local_err);
617 }
618 exit(EXIT_FAILURE);
Juan Quintela511c0232010-06-09 14:10:55 +0200619}
620
Juan Quintelab673eab2019-06-12 11:44:19 +0200621/**
622 * @migration_incoming_setup: Setup incoming migration
623 *
624 * Returns 0 for no error or 1 for error
625 *
626 * @f: file for main migration channel
627 * @errp: where to put errors
628 */
629static int migration_incoming_setup(QEMUFile *f, Error **errp)
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200630{
Juan Quintela4f0fae72017-07-24 12:42:02 +0200631 MigrationIncomingState *mis = migration_incoming_get_current();
Juan Quintelab673eab2019-06-12 11:44:19 +0200632 Error *local_err = NULL;
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200633
Juan Quintelab673eab2019-06-12 11:44:19 +0200634 if (multifd_load_setup(&local_err) != 0) {
Juan Quintelaf986c3d2016-01-14 16:52:55 +0100635 /* We haven't been able to create multifd threads
636 nothing better to do */
Juan Quintelab673eab2019-06-12 11:44:19 +0200637 error_report_err(local_err);
Juan Quintelaf986c3d2016-01-14 16:52:55 +0100638 exit(EXIT_FAILURE);
639 }
640
Juan Quintela4f0fae72017-07-24 12:42:02 +0200641 if (!mis->from_src_file) {
642 mis->from_src_file = f;
643 }
Daniel P. Berrange06ad5132016-04-27 11:04:56 +0100644 qemu_file_set_blocking(f, false);
Juan Quintelab673eab2019-06-12 11:44:19 +0200645 return 0;
Juan Quintelae595a012017-07-17 12:30:25 +0200646}
647
Juan Quintela36c2f8b2018-03-07 08:40:52 +0100648void migration_incoming_process(void)
Juan Quintelae595a012017-07-17 12:30:25 +0200649{
650 Coroutine *co = qemu_coroutine_create(process_incoming_migration_co, NULL);
Paolo Bonzini0b8b8752016-07-04 19:10:01 +0200651 qemu_coroutine_enter(co);
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200652}
653
Peter Xu884835f2018-06-27 21:22:45 +0800654/* Returns true if recovered from a paused migration, otherwise false */
655static bool postcopy_try_recover(QEMUFile *f)
Juan Quintelae595a012017-07-17 12:30:25 +0200656{
Peter Xud96c9e82018-05-02 18:47:26 +0800657 MigrationIncomingState *mis = migration_incoming_get_current();
658
659 if (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
660 /* Resumed from a paused postcopy migration */
661
662 mis->from_src_file = f;
663 /* Postcopy has standalone thread to do vm load */
664 qemu_file_set_blocking(f, true);
665
666 /* Re-configure the return path */
667 mis->to_src_file = qemu_file_get_return_path(f);
668
669 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_PAUSED,
670 MIGRATION_STATUS_POSTCOPY_RECOVER);
671
672 /*
673 * Here, we only wake up the main loading thread (while the
674 * fault thread will still be waiting), so that we can receive
675 * commands from source now, and answer it if needed. The
676 * fault thread will be woken up afterwards until we are sure
677 * that source is ready to reply to page requests.
678 */
679 qemu_sem_post(&mis->postcopy_pause_sem_dst);
Peter Xu884835f2018-06-27 21:22:45 +0800680 return true;
Peter Xud96c9e82018-05-02 18:47:26 +0800681 }
Peter Xu884835f2018-06-27 21:22:45 +0800682
683 return false;
684}
685
Juan Quintelab673eab2019-06-12 11:44:19 +0200686void migration_fd_process_incoming(QEMUFile *f, Error **errp)
Peter Xu884835f2018-06-27 21:22:45 +0800687{
Juan Quintelab673eab2019-06-12 11:44:19 +0200688 Error *local_err = NULL;
689
Peter Xu884835f2018-06-27 21:22:45 +0800690 if (postcopy_try_recover(f)) {
691 return;
692 }
693
Juan Quintelab673eab2019-06-12 11:44:19 +0200694 if (migration_incoming_setup(f, &local_err)) {
Markus Armbruster2155cea2020-07-22 10:40:47 +0200695 error_propagate(errp, local_err);
Juan Quintelab673eab2019-06-12 11:44:19 +0200696 return;
697 }
Peter Xu884835f2018-06-27 21:22:45 +0800698 migration_incoming_process();
Juan Quintelae595a012017-07-17 12:30:25 +0200699}
700
Fei Li49ed0d22019-01-13 22:08:46 +0800701void migration_ioc_process_incoming(QIOChannel *ioc, Error **errp)
Juan Quintela4f0fae72017-07-24 12:42:02 +0200702{
703 MigrationIncomingState *mis = migration_incoming_get_current();
Juan Quintelab673eab2019-06-12 11:44:19 +0200704 Error *local_err = NULL;
Peter Xua429e7f2018-06-27 21:22:46 +0800705 bool start_migration;
Juan Quintela4f0fae72017-07-24 12:42:02 +0200706
707 if (!mis->from_src_file) {
Peter Xua429e7f2018-06-27 21:22:46 +0800708 /* The first connection (multifd may have multiple) */
Juan Quintela4f0fae72017-07-24 12:42:02 +0200709 QEMUFile *f = qemu_fopen_channel_input(ioc);
Peter Xua429e7f2018-06-27 21:22:46 +0800710
711 /* If it's a recovery, we're done */
Peter Xu884835f2018-06-27 21:22:45 +0800712 if (postcopy_try_recover(f)) {
713 return;
714 }
Peter Xua429e7f2018-06-27 21:22:46 +0800715
Juan Quintelab673eab2019-06-12 11:44:19 +0200716 if (migration_incoming_setup(f, &local_err)) {
Markus Armbruster2155cea2020-07-22 10:40:47 +0200717 error_propagate(errp, local_err);
Juan Quintelab673eab2019-06-12 11:44:19 +0200718 return;
719 }
Peter Xua429e7f2018-06-27 21:22:46 +0800720
721 /*
722 * Common migration only needs one channel, so we can start
723 * right now. Multifd needs more than one channel, we wait.
724 */
725 start_migration = !migrate_use_multifd();
726 } else {
727 /* Multiple connections */
728 assert(migrate_use_multifd());
Fei Li49ed0d22019-01-13 22:08:46 +0800729 start_migration = multifd_recv_new_channel(ioc, &local_err);
730 if (local_err) {
731 error_propagate(errp, local_err);
732 return;
733 }
Juan Quintela4f0fae72017-07-24 12:42:02 +0200734 }
Peter Xu81e62052018-06-27 21:22:44 +0800735
Peter Xua429e7f2018-06-27 21:22:46 +0800736 if (start_migration) {
Peter Xu81e62052018-06-27 21:22:44 +0800737 migration_incoming_process();
738 }
Juan Quintela4f0fae72017-07-24 12:42:02 +0200739}
740
Juan Quintela428d8902017-07-24 13:06:25 +0200741/**
742 * @migration_has_all_channels: We have received all channels that we need
743 *
744 * Returns true when we have got connections to all the channels that
745 * we need for migration.
746 */
747bool migration_has_all_channels(void)
748{
Daniel P. Berrangéca273df2018-06-19 17:35:52 +0100749 MigrationIncomingState *mis = migration_incoming_get_current();
Juan Quintela62c1e0c2018-02-19 18:59:02 +0100750 bool all_channels;
751
752 all_channels = multifd_recv_all_channels_created();
753
Daniel P. Berrangéca273df2018-06-19 17:35:52 +0100754 return all_channels && mis->from_src_file != NULL;
Juan Quintela428d8902017-07-24 13:06:25 +0200755}
756
Dr. David Alan Gilbert6decec92015-11-05 18:10:47 +0000757/*
Dr. David Alan Gilbert6decec92015-11-05 18:10:47 +0000758 * Send a 'SHUT' message on the return channel with the given value
759 * to indicate that we've finished with the RP. Non-0 value indicates
760 * error.
761 */
762void migrate_send_rp_shut(MigrationIncomingState *mis,
763 uint32_t value)
764{
765 uint32_t buf;
766
767 buf = cpu_to_be32(value);
768 migrate_send_rp_message(mis, MIG_RP_MSG_SHUT, sizeof(buf), &buf);
769}
770
771/*
772 * Send a 'PONG' message on the return channel with the given value
773 * (normally in response to a 'PING')
774 */
775void migrate_send_rp_pong(MigrationIncomingState *mis,
776 uint32_t value)
777{
778 uint32_t buf;
779
780 buf = cpu_to_be32(value);
781 migrate_send_rp_message(mis, MIG_RP_MSG_PONG, sizeof(buf), &buf);
782}
783
Peter Xua335deb2018-05-02 18:47:28 +0800784void migrate_send_rp_recv_bitmap(MigrationIncomingState *mis,
785 char *block_name)
786{
787 char buf[512];
788 int len;
789 int64_t res;
790
791 /*
792 * First, we send the header part. It contains only the len of
793 * idstr, and the idstr itself.
794 */
795 len = strlen(block_name);
796 buf[0] = len;
797 memcpy(buf + 1, block_name, len);
798
799 if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
800 error_report("%s: MSG_RP_RECV_BITMAP only used for recovery",
801 __func__);
802 return;
803 }
804
805 migrate_send_rp_message(mis, MIG_RP_MSG_RECV_BITMAP, len + 1, buf);
806
807 /*
808 * Next, we dump the received bitmap to the stream.
809 *
810 * TODO: currently we are safe since we are the only one that is
811 * using the to_src_file handle (fault thread is still paused),
812 * and it's ok even not taking the mutex. However the best way is
813 * to take the lock before sending the message header, and release
814 * the lock after sending the bitmap.
815 */
816 qemu_mutex_lock(&mis->rp_mutex);
817 res = ramblock_recv_bitmap_send(mis->to_src_file, block_name);
818 qemu_mutex_unlock(&mis->rp_mutex);
819
820 trace_migrate_send_rp_recv_bitmap(block_name, res);
821}
822
Peter Xu13955b82018-05-02 18:47:30 +0800823void migrate_send_rp_resume_ack(MigrationIncomingState *mis, uint32_t value)
824{
825 uint32_t buf;
826
827 buf = cpu_to_be32(value);
828 migrate_send_rp_message(mis, MIG_RP_MSG_RESUME_ACK, sizeof(buf), &buf);
829}
830
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300831MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
832{
Eric Blake95b3a8c2021-01-13 16:10:13 -0600833 MigrationCapabilityStatusList *head = NULL, **tail = &head;
834 MigrationCapabilityStatus *caps;
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300835 MigrationState *s = migrate_get_current();
836 int i;
837
Eric Blake7fb1cf12015-11-18 01:52:57 -0700838 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
Dr. David Alan Gilberted1701c2017-05-15 15:05:29 +0100839#ifndef CONFIG_LIVE_BLOCK_MIGRATION
840 if (i == MIGRATION_CAPABILITY_BLOCK) {
841 continue;
842 }
843#endif
Eric Blake95b3a8c2021-01-13 16:10:13 -0600844 caps = g_malloc0(sizeof(*caps));
845 caps->capability = i;
846 caps->state = s->enabled_capabilities[i];
847 QAPI_LIST_APPEND(tail, caps);
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300848 }
849
850 return head;
851}
852
Liang Li85de8322015-03-23 16:32:28 +0800853MigrationParameters *qmp_query_migrate_parameters(Error **errp)
854{
855 MigrationParameters *params;
856 MigrationState *s = migrate_get_current();
857
Markus Armbrustere87fae42017-07-18 12:57:38 +0200858 /* TODO use QAPI_CLONE() instead of duplicating it inline */
Liang Li85de8322015-03-23 16:32:28 +0800859 params = g_malloc0(sizeof(*params));
Eric Blakede63ab62016-09-08 22:14:15 -0500860 params->has_compress_level = true;
Daniel P. Berrange2594f562016-04-27 11:05:14 +0100861 params->compress_level = s->parameters.compress_level;
Eric Blakede63ab62016-09-08 22:14:15 -0500862 params->has_compress_threads = true;
Daniel P. Berrange2594f562016-04-27 11:05:14 +0100863 params->compress_threads = s->parameters.compress_threads;
Xiao Guangrong1d588722018-08-21 16:10:20 +0800864 params->has_compress_wait_thread = true;
865 params->compress_wait_thread = s->parameters.compress_wait_thread;
Eric Blakede63ab62016-09-08 22:14:15 -0500866 params->has_decompress_threads = true;
Daniel P. Berrange2594f562016-04-27 11:05:14 +0100867 params->decompress_threads = s->parameters.decompress_threads;
Keqian Zhudc14a472020-02-24 10:31:42 +0800868 params->has_throttle_trigger_threshold = true;
869 params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold;
Eric Blakede63ab62016-09-08 22:14:15 -0500870 params->has_cpu_throttle_initial = true;
Daniel P. Berrange2594f562016-04-27 11:05:14 +0100871 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial;
Eric Blakede63ab62016-09-08 22:14:15 -0500872 params->has_cpu_throttle_increment = true;
Daniel P. Berrange2594f562016-04-27 11:05:14 +0100873 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
Keqian Zhucbbf8182020-04-13 18:15:08 +0800874 params->has_cpu_throttle_tailslow = true;
875 params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow;
Markus Armbruster8cc99dc2017-07-18 12:04:54 +0200876 params->has_tls_creds = true;
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +0100877 params->tls_creds = g_strdup(s->parameters.tls_creds);
Markus Armbruster8cc99dc2017-07-18 12:04:54 +0200878 params->has_tls_hostname = true;
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +0100879 params->tls_hostname = g_strdup(s->parameters.tls_hostname);
Daniel P. Berranged2f1d292019-02-27 14:53:24 +0000880 params->has_tls_authz = true;
Mao Zhongyi7cd75cb2020-03-25 09:49:30 +0800881 params->tls_authz = g_strdup(s->parameters.tls_authz ?
882 s->parameters.tls_authz : "");
Ashijeet Acharya2ff30252016-09-15 21:50:28 +0530883 params->has_max_bandwidth = true;
884 params->max_bandwidth = s->parameters.max_bandwidth;
885 params->has_downtime_limit = true;
886 params->downtime_limit = s->parameters.downtime_limit;
zhanghailiangfe39a4d2016-11-02 15:42:09 +0800887 params->has_x_checkpoint_delay = true;
zhanghailiang68b53592016-10-27 14:43:01 +0800888 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay;
Juan Quintela2833c592017-04-05 18:32:37 +0200889 params->has_block_incremental = true;
890 params->block_incremental = s->parameters.block_incremental;
Juan Quintelacbfd6c92019-02-06 13:54:06 +0100891 params->has_multifd_channels = true;
892 params->multifd_channels = s->parameters.multifd_channels;
Juan Quintela96eef042019-01-16 10:35:55 +0100893 params->has_multifd_compression = true;
894 params->multifd_compression = s->parameters.multifd_compression;
Juan Quintela9004db42020-01-23 17:08:52 +0100895 params->has_multifd_zlib_level = true;
896 params->multifd_zlib_level = s->parameters.multifd_zlib_level;
Juan Quintela6a9ad152020-01-23 17:41:36 +0100897 params->has_multifd_zstd_level = true;
898 params->multifd_zstd_level = s->parameters.multifd_zstd_level;
Juan Quintela73af8dd2017-10-05 21:30:10 +0200899 params->has_xbzrle_cache_size = true;
900 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +0100901 params->has_max_postcopy_bandwidth = true;
902 params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;
Li Qiang4cbc9c72018-08-01 06:00:20 -0700903 params->has_max_cpu_throttle = true;
904 params->max_cpu_throttle = s->parameters.max_cpu_throttle;
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +0000905 params->has_announce_initial = true;
906 params->announce_initial = s->parameters.announce_initial;
907 params->has_announce_max = true;
908 params->announce_max = s->parameters.announce_max;
909 params->has_announce_rounds = true;
910 params->announce_rounds = s->parameters.announce_rounds;
911 params->has_announce_step = true;
912 params->announce_step = s->parameters.announce_step;
Liang Li85de8322015-03-23 16:32:28 +0800913
Max Reitz31e4c352020-08-20 17:07:23 +0200914 if (s->parameters.has_block_bitmap_mapping) {
915 params->has_block_bitmap_mapping = true;
916 params->block_bitmap_mapping =
917 QAPI_CLONE(BitmapMigrationNodeAliasList,
918 s->parameters.block_bitmap_mapping);
919 }
920
Liang Li85de8322015-03-23 16:32:28 +0800921 return params;
922}
923
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +0000924AnnounceParameters *migrate_announce_params(void)
925{
926 static AnnounceParameters ap;
927
928 MigrationState *s = migrate_get_current();
929
930 ap.initial = s->parameters.announce_initial;
931 ap.max = s->parameters.announce_max;
932 ap.rounds = s->parameters.announce_rounds;
933 ap.step = s->parameters.announce_step;
934
935 return &ap;
936}
937
Dr. David Alan Gilbertf6844b92015-11-05 18:10:48 +0000938/*
939 * Return true if we're already in the middle of a migration
940 * (i.e. any of the active or setup states)
941 */
Jia Lina3d63da12018-10-26 16:36:20 +0800942bool migration_is_setup_or_active(int state)
Dr. David Alan Gilbertf6844b92015-11-05 18:10:48 +0000943{
944 switch (state) {
945 case MIGRATION_STATUS_ACTIVE:
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +0000946 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
Peter Xua688d2c2018-05-02 18:47:18 +0800947 case MIGRATION_STATUS_POSTCOPY_PAUSED:
Peter Xu135b87b2018-05-02 18:47:25 +0800948 case MIGRATION_STATUS_POSTCOPY_RECOVER:
Dr. David Alan Gilbertf6844b92015-11-05 18:10:48 +0000949 case MIGRATION_STATUS_SETUP:
Dr. David Alan Gilbert31e06072017-10-20 10:05:51 +0100950 case MIGRATION_STATUS_PRE_SWITCHOVER:
951 case MIGRATION_STATUS_DEVICE:
Jens Freimannc7e0acd2019-10-29 12:49:02 +0100952 case MIGRATION_STATUS_WAIT_UNPLUG:
zhanghailiang19dd4082020-02-24 14:54:12 +0800953 case MIGRATION_STATUS_COLO:
Dr. David Alan Gilbertf6844b92015-11-05 18:10:48 +0000954 return true;
955
956 default:
957 return false;
958
959 }
960}
961
Juan Quintela392d87e2020-01-21 15:39:23 +0100962bool migration_is_running(int state)
963{
964 switch (state) {
965 case MIGRATION_STATUS_ACTIVE:
966 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
967 case MIGRATION_STATUS_POSTCOPY_PAUSED:
968 case MIGRATION_STATUS_POSTCOPY_RECOVER:
969 case MIGRATION_STATUS_SETUP:
970 case MIGRATION_STATUS_PRE_SWITCHOVER:
971 case MIGRATION_STATUS_DEVICE:
972 case MIGRATION_STATUS_WAIT_UNPLUG:
973 case MIGRATION_STATUS_CANCELLING:
Juan Quintela392d87e2020-01-21 15:39:23 +0100974 return true;
975
976 default:
977 return false;
978
979 }
980}
981
Wei Yang640dfb12019-07-16 08:54:11 +0800982static void populate_time_info(MigrationInfo *info, MigrationState *s)
983{
984 info->has_status = true;
985 info->has_setup_time = true;
986 info->setup_time = s->setup_time;
987 if (s->state == MIGRATION_STATUS_COMPLETED) {
988 info->has_total_time = true;
989 info->total_time = s->total_time;
990 info->has_downtime = true;
991 info->downtime = s->downtime;
992 } else {
993 info->has_total_time = true;
994 info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) -
995 s->start_time;
996 info->has_expected_downtime = true;
997 info->expected_downtime = s->expected_downtime;
998 }
999}
1000
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001001static void populate_ram_info(MigrationInfo *info, MigrationState *s)
1002{
1003 info->has_ram = true;
1004 info->ram = g_malloc0(sizeof(*info->ram));
Juan Quintela93604472017-06-06 19:49:03 +02001005 info->ram->transferred = ram_counters.transferred;
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001006 info->ram->total = ram_bytes_total();
Juan Quintela93604472017-06-06 19:49:03 +02001007 info->ram->duplicate = ram_counters.duplicate;
Juan Quintelabedf53c2017-03-13 20:35:54 +01001008 /* legacy value. It is not used anymore */
1009 info->ram->skipped = 0;
Juan Quintela93604472017-06-06 19:49:03 +02001010 info->ram->normal = ram_counters.normal;
1011 info->ram->normal_bytes = ram_counters.normal *
Juan Quintela20afaed2017-03-21 09:09:14 +01001012 qemu_target_page_size();
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001013 info->ram->mbps = s->mbps;
Juan Quintela93604472017-06-06 19:49:03 +02001014 info->ram->dirty_sync_count = ram_counters.dirty_sync_count;
1015 info->ram->postcopy_requests = ram_counters.postcopy_requests;
Chao Fan030ce1f2017-03-21 10:22:43 +08001016 info->ram->page_size = qemu_target_page_size();
Juan Quintelaa61c45b2018-06-26 15:20:11 +02001017 info->ram->multifd_bytes = ram_counters.multifd_bytes;
Xiao Guangrongaecbfe92019-01-11 14:37:30 +08001018 info->ram->pages_per_second = s->pages_per_second;
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001019
Juan Quintela114f5ae2017-05-04 10:09:21 +02001020 if (migrate_use_xbzrle()) {
1021 info->has_xbzrle_cache = true;
1022 info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
1023 info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
Juan Quintela93604472017-06-06 19:49:03 +02001024 info->xbzrle_cache->bytes = xbzrle_counters.bytes;
1025 info->xbzrle_cache->pages = xbzrle_counters.pages;
1026 info->xbzrle_cache->cache_miss = xbzrle_counters.cache_miss;
1027 info->xbzrle_cache->cache_miss_rate = xbzrle_counters.cache_miss_rate;
Wei Wange460a4b2020-04-30 08:59:35 +08001028 info->xbzrle_cache->encoding_rate = xbzrle_counters.encoding_rate;
Juan Quintela93604472017-06-06 19:49:03 +02001029 info->xbzrle_cache->overflow = xbzrle_counters.overflow;
Juan Quintela114f5ae2017-05-04 10:09:21 +02001030 }
1031
Xiao Guangrong76e03002018-09-06 15:01:00 +08001032 if (migrate_use_compression()) {
1033 info->has_compression = true;
1034 info->compression = g_malloc0(sizeof(*info->compression));
1035 info->compression->pages = compression_counters.pages;
1036 info->compression->busy = compression_counters.busy;
1037 info->compression->busy_rate = compression_counters.busy_rate;
1038 info->compression->compressed_size =
1039 compression_counters.compressed_size;
1040 info->compression->compression_rate =
1041 compression_counters.compression_rate;
1042 }
1043
Juan Quintela338182c2017-05-03 13:16:38 +02001044 if (cpu_throttle_active()) {
1045 info->has_cpu_throttle_percentage = true;
1046 info->cpu_throttle_percentage = cpu_throttle_get_percentage();
1047 }
1048
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001049 if (s->state != MIGRATION_STATUS_COMPLETED) {
1050 info->ram->remaining = ram_bytes_remaining();
Juan Quintela93604472017-06-06 19:49:03 +02001051 info->ram->dirty_pages_rate = ram_counters.dirty_pages_rate;
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001052 }
1053}
1054
Juan Quintela930ac042017-05-04 10:21:46 +02001055static void populate_disk_info(MigrationInfo *info)
1056{
1057 if (blk_mig_active()) {
1058 info->has_disk = true;
1059 info->disk = g_malloc0(sizeof(*info->disk));
1060 info->disk->transferred = blk_mig_bytes_transferred();
1061 info->disk->remaining = blk_mig_bytes_remaining();
1062 info->disk->total = blk_mig_bytes_total();
1063 }
1064}
1065
Alexey Perevalov65ace062018-03-22 21:17:27 +03001066static void fill_source_migration_info(MigrationInfo *info)
aliguori5bb79102008-10-13 03:12:02 +00001067{
Juan Quintela17549e82011-10-05 13:50:43 +02001068 MigrationState *s = migrate_get_current();
Markus Armbruster372043f2021-04-29 16:04:24 +02001069 GSList *cur_blocker = migration_blockers;
aliguori376253e2009-03-05 23:01:23 +00001070
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +00001071 info->blocked_reasons = NULL;
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +00001072
Markus Armbruster372043f2021-04-29 16:04:24 +02001073 /*
1074 * There are two types of reasons a migration might be blocked;
1075 * a) devices marked in VMState as non-migratable, and
1076 * b) Explicit migration blockers
1077 * We need to add both of them here.
1078 */
1079 qemu_savevm_non_migratable_list(&info->blocked_reasons);
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +00001080
Markus Armbruster372043f2021-04-29 16:04:24 +02001081 while (cur_blocker) {
1082 QAPI_LIST_PREPEND(info->blocked_reasons,
1083 g_strdup(error_get_pretty(cur_blocker->data)));
1084 cur_blocker = g_slist_next(cur_blocker);
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +00001085 }
Markus Armbruster372043f2021-04-29 16:04:24 +02001086 info->has_blocked_reasons = info->blocked_reasons != NULL;
Dr. David Alan Gilbert3af85542021-02-02 13:55:21 +00001087
Juan Quintela17549e82011-10-05 13:50:43 +02001088 switch (s->state) {
zhanghailiang31194732015-03-13 16:08:38 +08001089 case MIGRATION_STATUS_NONE:
Juan Quintela17549e82011-10-05 13:50:43 +02001090 /* no migration has happened ever */
Alexey Perevalov65ace062018-03-22 21:17:27 +03001091 /* do not overwrite destination migration status */
1092 return;
zhanghailiang31194732015-03-13 16:08:38 +08001093 case MIGRATION_STATUS_SETUP:
Michael R. Hines29ae8a42013-07-22 10:01:57 -04001094 info->has_status = true;
Michael R. Hinesed4fbd12013-07-22 10:01:58 -04001095 info->has_total_time = false;
Michael R. Hines29ae8a42013-07-22 10:01:57 -04001096 break;
zhanghailiang31194732015-03-13 16:08:38 +08001097 case MIGRATION_STATUS_ACTIVE:
1098 case MIGRATION_STATUS_CANCELLING:
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +00001099 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
Dr. David Alan Gilbert31e06072017-10-20 10:05:51 +01001100 case MIGRATION_STATUS_PRE_SWITCHOVER:
1101 case MIGRATION_STATUS_DEVICE:
Peter Xua688d2c2018-05-02 18:47:18 +08001102 case MIGRATION_STATUS_POSTCOPY_PAUSED:
Peter Xu135b87b2018-05-02 18:47:25 +08001103 case MIGRATION_STATUS_POSTCOPY_RECOVER:
Wei Yang640dfb12019-07-16 08:54:11 +08001104 /* TODO add some postcopy stats */
1105 populate_time_info(info, s);
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001106 populate_ram_info(info, s);
Juan Quintela930ac042017-05-04 10:21:46 +02001107 populate_disk_info(info);
Kirti Wankhede37105862020-10-26 15:06:27 +05301108 populate_vfio_info(info);
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +00001109 break;
zhanghailiang0b827d52016-10-27 14:42:54 +08001110 case MIGRATION_STATUS_COLO:
1111 info->has_status = true;
1112 /* TODO: display COLO specific information (checkpoint info etc.) */
1113 break;
zhanghailiang31194732015-03-13 16:08:38 +08001114 case MIGRATION_STATUS_COMPLETED:
Wei Yang640dfb12019-07-16 08:54:11 +08001115 populate_time_info(info, s);
Dr. David Alan Gilberta22463a2016-06-13 12:16:41 +01001116 populate_ram_info(info, s);
Kirti Wankhede37105862020-10-26 15:06:27 +05301117 populate_vfio_info(info);
Juan Quintela17549e82011-10-05 13:50:43 +02001118 break;
zhanghailiang31194732015-03-13 16:08:38 +08001119 case MIGRATION_STATUS_FAILED:
Luiz Capitulino791e7c82011-09-13 17:37:16 -03001120 info->has_status = true;
Daniel P. Berranged59ce6f2016-04-27 11:05:00 +01001121 if (s->error) {
1122 info->has_error_desc = true;
1123 info->error_desc = g_strdup(error_get_pretty(s->error));
1124 }
Juan Quintela17549e82011-10-05 13:50:43 +02001125 break;
zhanghailiang31194732015-03-13 16:08:38 +08001126 case MIGRATION_STATUS_CANCELLED:
Luiz Capitulino791e7c82011-09-13 17:37:16 -03001127 info->has_status = true;
Juan Quintela17549e82011-10-05 13:50:43 +02001128 break;
Jens Freimannc7e0acd2019-10-29 12:49:02 +01001129 case MIGRATION_STATUS_WAIT_UNPLUG:
1130 info->has_status = true;
1131 break;
aliguori5bb79102008-10-13 03:12:02 +00001132 }
zhanghailiangcde63fb2015-03-13 16:08:41 +08001133 info->status = s->state;
aliguori5bb79102008-10-13 03:12:02 +00001134}
1135
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +03001136typedef enum WriteTrackingSupport {
1137 WT_SUPPORT_UNKNOWN = 0,
1138 WT_SUPPORT_ABSENT,
1139 WT_SUPPORT_AVAILABLE,
1140 WT_SUPPORT_COMPATIBLE
1141} WriteTrackingSupport;
1142
1143static
1144WriteTrackingSupport migrate_query_write_tracking(void)
1145{
1146 /* Check if kernel supports required UFFD features */
1147 if (!ram_write_tracking_available()) {
1148 return WT_SUPPORT_ABSENT;
1149 }
1150 /*
1151 * Check if current memory configuration is
1152 * compatible with required UFFD features.
1153 */
1154 if (!ram_write_tracking_compatible()) {
1155 return WT_SUPPORT_AVAILABLE;
1156 }
1157
1158 return WT_SUPPORT_COMPATIBLE;
1159}
1160
Peter Xu4a842142017-07-18 11:39:08 +08001161/**
1162 * @migration_caps_check - check capability validity
1163 *
1164 * @cap_list: old capability list, array of bool
1165 * @params: new capabilities to be applied soon
1166 * @errp: set *errp if the check failed, with reason
1167 *
1168 * Returns true if check passed, otherwise false.
1169 */
1170static bool migrate_caps_check(bool *cap_list,
1171 MigrationCapabilityStatusList *params,
1172 Error **errp)
Orit Wasserman00458432012-08-06 21:42:48 +03001173{
Orit Wasserman00458432012-08-06 21:42:48 +03001174 MigrationCapabilityStatusList *cap;
Peter Xu4a842142017-07-18 11:39:08 +08001175 bool old_postcopy_cap;
Alexey Perevalovd7651f12017-09-19 19:47:56 +03001176 MigrationIncomingState *mis = migration_incoming_get_current();
Orit Wasserman00458432012-08-06 21:42:48 +03001177
Peter Xu4a842142017-07-18 11:39:08 +08001178 old_postcopy_cap = cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM];
Orit Wasserman00458432012-08-06 21:42:48 +03001179
1180 for (cap = params; cap; cap = cap->next) {
Peter Xu4a842142017-07-18 11:39:08 +08001181 cap_list[cap->value->capability] = cap->value->state;
Orit Wasserman00458432012-08-06 21:42:48 +03001182 }
Dr. David Alan Gilbert53dd3702015-11-05 18:10:51 +00001183
Peter Xu4a842142017-07-18 11:39:08 +08001184#ifndef CONFIG_LIVE_BLOCK_MIGRATION
1185 if (cap_list[MIGRATION_CAPABILITY_BLOCK]) {
1186 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) "
1187 "block migration");
1188 error_append_hint(errp, "Use drive_mirror+NBD instead.\n");
1189 return false;
1190 }
1191#endif
1192
Zhang Chen7e934f52018-11-15 03:09:12 +08001193#ifndef CONFIG_REPLICATION
1194 if (cap_list[MIGRATION_CAPABILITY_X_COLO]) {
1195 error_setg(errp, "QEMU compiled without replication module"
1196 " can't enable COLO");
1197 error_append_hint(errp, "Please enable replication before COLO.\n");
1198 return false;
1199 }
1200#endif
1201
Peter Xu4a842142017-07-18 11:39:08 +08001202 if (cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
Dr. David Alan Gilbert096631b2016-06-13 12:16:45 +01001203 /* This check is reasonably expensive, so only when it's being
1204 * set the first time, also it's only the destination that needs
1205 * special support.
1206 */
1207 if (!old_postcopy_cap && runstate_check(RUN_STATE_INMIGRATE) &&
Alexey Perevalovd7651f12017-09-19 19:47:56 +03001208 !postcopy_ram_supported_by_host(mis)) {
Dr. David Alan Gilbert096631b2016-06-13 12:16:45 +01001209 /* postcopy_ram_supported_by_host will have emitted a more
1210 * detailed message
1211 */
Peter Xu4a842142017-07-18 11:39:08 +08001212 error_setg(errp, "Postcopy is not supported");
1213 return false;
Dr. David Alan Gilbert096631b2016-06-13 12:16:45 +01001214 }
Yury Kotov18269062019-02-15 20:45:45 +03001215
1216 if (cap_list[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) {
1217 error_setg(errp, "Postcopy is not compatible with ignore-shared");
1218 return false;
1219 }
Dr. David Alan Gilbert53dd3702015-11-05 18:10:51 +00001220 }
Peter Xu4a842142017-07-18 11:39:08 +08001221
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +03001222 if (cap_list[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]) {
1223 WriteTrackingSupport wt_support;
1224 int idx;
1225 /*
1226 * Check if 'background-snapshot' capability is supported by
1227 * host kernel and compatible with guest memory configuration.
1228 */
1229 wt_support = migrate_query_write_tracking();
1230 if (wt_support < WT_SUPPORT_AVAILABLE) {
1231 error_setg(errp, "Background-snapshot is not supported by host kernel");
1232 return false;
1233 }
1234 if (wt_support < WT_SUPPORT_COMPATIBLE) {
1235 error_setg(errp, "Background-snapshot is not compatible "
1236 "with guest memory configuration");
1237 return false;
1238 }
1239
1240 /*
1241 * Check if there are any migration capabilities
1242 * incompatible with 'background-snapshot'.
1243 */
1244 for (idx = 0; idx < check_caps_background_snapshot.size; idx++) {
1245 int incomp_cap = check_caps_background_snapshot.caps[idx];
1246 if (cap_list[incomp_cap]) {
1247 error_setg(errp,
1248 "Background-snapshot is not compatible with %s",
1249 MigrationCapability_str(incomp_cap));
1250 return false;
1251 }
1252 }
1253 }
1254
Peter Xu4a842142017-07-18 11:39:08 +08001255 return true;
1256}
1257
Alexey Perevalov65ace062018-03-22 21:17:27 +03001258static void fill_destination_migration_info(MigrationInfo *info)
1259{
1260 MigrationIncomingState *mis = migration_incoming_get_current();
1261
Juan Quintela9aca82b2019-02-27 11:51:27 +01001262 if (mis->socket_address_list) {
1263 info->has_socket_address = true;
1264 info->socket_address =
1265 QAPI_CLONE(SocketAddressList, mis->socket_address_list);
1266 }
1267
Alexey Perevalov65ace062018-03-22 21:17:27 +03001268 switch (mis->state) {
1269 case MIGRATION_STATUS_NONE:
1270 return;
Alexey Perevalov65ace062018-03-22 21:17:27 +03001271 case MIGRATION_STATUS_SETUP:
1272 case MIGRATION_STATUS_CANCELLING:
1273 case MIGRATION_STATUS_CANCELLED:
1274 case MIGRATION_STATUS_ACTIVE:
1275 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
Peter Xu3c9928d2018-07-10 17:18:56 +08001276 case MIGRATION_STATUS_POSTCOPY_PAUSED:
1277 case MIGRATION_STATUS_POSTCOPY_RECOVER:
Alexey Perevalov65ace062018-03-22 21:17:27 +03001278 case MIGRATION_STATUS_FAILED:
1279 case MIGRATION_STATUS_COLO:
1280 info->has_status = true;
1281 break;
1282 case MIGRATION_STATUS_COMPLETED:
1283 info->has_status = true;
1284 fill_destination_postcopy_migration_info(info);
1285 break;
1286 }
1287 info->status = mis->state;
1288}
1289
1290MigrationInfo *qmp_query_migrate(Error **errp)
1291{
1292 MigrationInfo *info = g_malloc0(sizeof(*info));
1293
1294 fill_destination_migration_info(info);
1295 fill_source_migration_info(info);
1296
1297 return info;
1298}
1299
Peter Xu4a842142017-07-18 11:39:08 +08001300void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
1301 Error **errp)
1302{
1303 MigrationState *s = migrate_get_current();
1304 MigrationCapabilityStatusList *cap;
Peter Xudd0ee302018-03-05 17:49:38 +08001305 bool cap_list[MIGRATION_CAPABILITY__MAX];
Peter Xu4a842142017-07-18 11:39:08 +08001306
Juan Quintela392d87e2020-01-21 15:39:23 +01001307 if (migration_is_running(s->state)) {
Peter Xu4a842142017-07-18 11:39:08 +08001308 error_setg(errp, QERR_MIGRATION_ACTIVE);
1309 return;
1310 }
1311
Peter Xudd0ee302018-03-05 17:49:38 +08001312 memcpy(cap_list, s->enabled_capabilities, sizeof(cap_list));
1313 if (!migrate_caps_check(cap_list, params, errp)) {
Peter Xu4a842142017-07-18 11:39:08 +08001314 return;
1315 }
1316
1317 for (cap = params; cap; cap = cap->next) {
1318 s->enabled_capabilities[cap->value->capability] = cap->value->state;
1319 }
Orit Wasserman00458432012-08-06 21:42:48 +03001320}
1321
Peter Xu16d063b2017-07-18 11:39:04 +08001322/*
1323 * Check whether the parameters are valid. Error will be put into errp
1324 * (if provided). Return true if valid, otherwise false.
1325 */
1326static bool migrate_params_check(MigrationParameters *params, Error **errp)
Liang Li85de8322015-03-23 16:32:28 +08001327{
Eric Blake7f375e02016-09-08 22:14:16 -05001328 if (params->has_compress_level &&
Juan Quintela741d4082017-12-01 13:08:38 +01001329 (params->compress_level > 9)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001330 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
Markus Armbruster54270c42021-02-02 15:17:34 +01001331 "a value between 0 and 9");
Peter Xu16d063b2017-07-18 11:39:04 +08001332 return false;
Liang Li85de8322015-03-23 16:32:28 +08001333 }
Peter Xu16d063b2017-07-18 11:39:04 +08001334
Juan Quintela741d4082017-12-01 13:08:38 +01001335 if (params->has_compress_threads && (params->compress_threads < 1)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001336 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1337 "compress_threads",
Markus Armbruster54270c42021-02-02 15:17:34 +01001338 "a value between 1 and 255");
Peter Xu16d063b2017-07-18 11:39:04 +08001339 return false;
Liang Li85de8322015-03-23 16:32:28 +08001340 }
Peter Xu16d063b2017-07-18 11:39:04 +08001341
Juan Quintela741d4082017-12-01 13:08:38 +01001342 if (params->has_decompress_threads && (params->decompress_threads < 1)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001343 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1344 "decompress_threads",
Markus Armbruster54270c42021-02-02 15:17:34 +01001345 "a value between 1 and 255");
Peter Xu16d063b2017-07-18 11:39:04 +08001346 return false;
Liang Li85de8322015-03-23 16:32:28 +08001347 }
Peter Xu16d063b2017-07-18 11:39:04 +08001348
Keqian Zhudc14a472020-02-24 10:31:42 +08001349 if (params->has_throttle_trigger_threshold &&
1350 (params->throttle_trigger_threshold < 1 ||
1351 params->throttle_trigger_threshold > 100)) {
1352 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1353 "throttle_trigger_threshold",
1354 "an integer in the range of 1 to 100");
1355 return false;
1356 }
1357
Eric Blake7f375e02016-09-08 22:14:16 -05001358 if (params->has_cpu_throttle_initial &&
1359 (params->cpu_throttle_initial < 1 ||
1360 params->cpu_throttle_initial > 99)) {
Jason J. Herne1626fee2015-09-08 13:12:34 -04001361 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
Jason J. Herned85a31d2016-04-21 14:07:18 -04001362 "cpu_throttle_initial",
Jason J. Herne1626fee2015-09-08 13:12:34 -04001363 "an integer in the range of 1 to 99");
Peter Xu16d063b2017-07-18 11:39:04 +08001364 return false;
Jason J. Herne1626fee2015-09-08 13:12:34 -04001365 }
Peter Xu16d063b2017-07-18 11:39:04 +08001366
Eric Blake7f375e02016-09-08 22:14:16 -05001367 if (params->has_cpu_throttle_increment &&
1368 (params->cpu_throttle_increment < 1 ||
1369 params->cpu_throttle_increment > 99)) {
Jason J. Herne1626fee2015-09-08 13:12:34 -04001370 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
Jason J. Herned85a31d2016-04-21 14:07:18 -04001371 "cpu_throttle_increment",
Jason J. Herne1626fee2015-09-08 13:12:34 -04001372 "an integer in the range of 1 to 99");
Peter Xu16d063b2017-07-18 11:39:04 +08001373 return false;
Jason J. Herne1626fee2015-09-08 13:12:34 -04001374 }
Peter Xu16d063b2017-07-18 11:39:04 +08001375
Juan Quintela741d4082017-12-01 13:08:38 +01001376 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
Mao Zhongyi2ee30cf2020-03-31 16:22:05 +08001377 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1378 "max_bandwidth",
1379 "an integer in the range of 0 to "stringify(SIZE_MAX)
1380 " bytes/second");
Peter Xu16d063b2017-07-18 11:39:04 +08001381 return false;
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301382 }
Peter Xu16d063b2017-07-18 11:39:04 +08001383
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301384 if (params->has_downtime_limit &&
Juan Quintela741d4082017-12-01 13:08:38 +01001385 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
Mao Zhongyi2ee30cf2020-03-31 16:22:05 +08001386 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1387 "downtime_limit",
1388 "an integer in the range of 0 to "
Mao Zhongyi7ac55292020-03-31 16:22:07 +08001389 stringify(MAX_MIGRATE_DOWNTIME)" ms");
Peter Xu16d063b2017-07-18 11:39:04 +08001390 return false;
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301391 }
Peter Xu16d063b2017-07-18 11:39:04 +08001392
Juan Quintela741d4082017-12-01 13:08:38 +01001393 /* x_checkpoint_delay is now always positive */
1394
Juan Quintelacbfd6c92019-02-06 13:54:06 +01001395 if (params->has_multifd_channels && (params->multifd_channels < 1)) {
Juan Quintela4075fb12016-01-15 08:56:17 +01001396 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1397 "multifd_channels",
Markus Armbruster54270c42021-02-02 15:17:34 +01001398 "a value between 1 and 255");
Juan Quintela4075fb12016-01-15 08:56:17 +01001399 return false;
1400 }
Peter Xu16d063b2017-07-18 11:39:04 +08001401
Juan Quintela9004db42020-01-23 17:08:52 +01001402 if (params->has_multifd_zlib_level &&
1403 (params->multifd_zlib_level > 9)) {
1404 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level",
Markus Armbruster54270c42021-02-02 15:17:34 +01001405 "a value between 0 and 9");
Juan Quintela9004db42020-01-23 17:08:52 +01001406 return false;
1407 }
1408
Juan Quintela6a9ad152020-01-23 17:41:36 +01001409 if (params->has_multifd_zstd_level &&
1410 (params->multifd_zstd_level > 20)) {
1411 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level",
Markus Armbruster54270c42021-02-02 15:17:34 +01001412 "a value between 0 and 20");
Juan Quintela6a9ad152020-01-23 17:41:36 +01001413 return false;
1414 }
1415
Juan Quintela73af8dd2017-10-05 21:30:10 +02001416 if (params->has_xbzrle_cache_size &&
1417 (params->xbzrle_cache_size < qemu_target_page_size() ||
1418 !is_power_of_2(params->xbzrle_cache_size))) {
1419 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1420 "xbzrle_cache_size",
Markus Armbruster54270c42021-02-02 15:17:34 +01001421 "a power of two no less than the target page size");
Juan Quintela73af8dd2017-10-05 21:30:10 +02001422 return false;
1423 }
1424
Li Qiang4cbc9c72018-08-01 06:00:20 -07001425 if (params->has_max_cpu_throttle &&
1426 (params->max_cpu_throttle < params->cpu_throttle_initial ||
1427 params->max_cpu_throttle > 99)) {
1428 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1429 "max_cpu_throttle",
1430 "an integer in the range of cpu_throttle_initial to 99");
1431 return false;
1432 }
1433
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001434 if (params->has_announce_initial &&
1435 params->announce_initial > 100000) {
1436 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1437 "announce_initial",
Markus Armbruster54270c42021-02-02 15:17:34 +01001438 "a value between 0 and 100000");
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001439 return false;
1440 }
1441 if (params->has_announce_max &&
1442 params->announce_max > 100000) {
1443 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1444 "announce_max",
Markus Armbruster54270c42021-02-02 15:17:34 +01001445 "a value between 0 and 100000");
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001446 return false;
1447 }
1448 if (params->has_announce_rounds &&
1449 params->announce_rounds > 1000) {
1450 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1451 "announce_rounds",
Markus Armbruster54270c42021-02-02 15:17:34 +01001452 "a value between 0 and 1000");
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001453 return false;
1454 }
1455 if (params->has_announce_step &&
1456 (params->announce_step < 1 ||
1457 params->announce_step > 10000)) {
1458 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1459 "announce_step",
Markus Armbruster54270c42021-02-02 15:17:34 +01001460 "a value between 0 and 10000");
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001461 return false;
1462 }
Max Reitz31e4c352020-08-20 17:07:23 +02001463
1464 if (params->has_block_bitmap_mapping &&
1465 !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) {
1466 error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: ");
1467 return false;
1468 }
1469
Peter Xu16d063b2017-07-18 11:39:04 +08001470 return true;
1471}
1472
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001473static void migrate_params_test_apply(MigrateSetParameters *params,
1474 MigrationParameters *dest)
1475{
1476 *dest = migrate_get_current()->parameters;
1477
1478 /* TODO use QAPI_CLONE() instead of duplicating it inline */
1479
1480 if (params->has_compress_level) {
1481 dest->compress_level = params->compress_level;
1482 }
1483
1484 if (params->has_compress_threads) {
1485 dest->compress_threads = params->compress_threads;
1486 }
1487
Xiao Guangrong1d588722018-08-21 16:10:20 +08001488 if (params->has_compress_wait_thread) {
1489 dest->compress_wait_thread = params->compress_wait_thread;
1490 }
1491
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001492 if (params->has_decompress_threads) {
1493 dest->decompress_threads = params->decompress_threads;
1494 }
1495
Keqian Zhudc14a472020-02-24 10:31:42 +08001496 if (params->has_throttle_trigger_threshold) {
1497 dest->throttle_trigger_threshold = params->throttle_trigger_threshold;
1498 }
1499
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001500 if (params->has_cpu_throttle_initial) {
1501 dest->cpu_throttle_initial = params->cpu_throttle_initial;
1502 }
1503
1504 if (params->has_cpu_throttle_increment) {
1505 dest->cpu_throttle_increment = params->cpu_throttle_increment;
1506 }
1507
Keqian Zhucbbf8182020-04-13 18:15:08 +08001508 if (params->has_cpu_throttle_tailslow) {
1509 dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow;
1510 }
1511
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001512 if (params->has_tls_creds) {
Markus Armbruster01fa5592017-07-18 14:42:04 +02001513 assert(params->tls_creds->type == QTYPE_QSTRING);
Zheng Chuan9728ebf2020-07-09 16:28:25 +08001514 dest->tls_creds = params->tls_creds->u.s;
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001515 }
1516
1517 if (params->has_tls_hostname) {
Markus Armbruster01fa5592017-07-18 14:42:04 +02001518 assert(params->tls_hostname->type == QTYPE_QSTRING);
Zheng Chuan9728ebf2020-07-09 16:28:25 +08001519 dest->tls_hostname = params->tls_hostname->u.s;
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001520 }
1521
1522 if (params->has_max_bandwidth) {
1523 dest->max_bandwidth = params->max_bandwidth;
1524 }
1525
1526 if (params->has_downtime_limit) {
1527 dest->downtime_limit = params->downtime_limit;
1528 }
1529
1530 if (params->has_x_checkpoint_delay) {
1531 dest->x_checkpoint_delay = params->x_checkpoint_delay;
1532 }
1533
1534 if (params->has_block_incremental) {
1535 dest->block_incremental = params->block_incremental;
1536 }
Juan Quintelacbfd6c92019-02-06 13:54:06 +01001537 if (params->has_multifd_channels) {
1538 dest->multifd_channels = params->multifd_channels;
Juan Quintela5e7577a2017-10-09 18:07:56 +02001539 }
Juan Quintela96eef042019-01-16 10:35:55 +01001540 if (params->has_multifd_compression) {
1541 dest->multifd_compression = params->multifd_compression;
1542 }
Juan Quintela73af8dd2017-10-05 21:30:10 +02001543 if (params->has_xbzrle_cache_size) {
1544 dest->xbzrle_cache_size = params->xbzrle_cache_size;
1545 }
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01001546 if (params->has_max_postcopy_bandwidth) {
1547 dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth;
1548 }
Li Qiang4cbc9c72018-08-01 06:00:20 -07001549 if (params->has_max_cpu_throttle) {
1550 dest->max_cpu_throttle = params->max_cpu_throttle;
1551 }
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001552 if (params->has_announce_initial) {
1553 dest->announce_initial = params->announce_initial;
1554 }
1555 if (params->has_announce_max) {
1556 dest->announce_max = params->announce_max;
1557 }
1558 if (params->has_announce_rounds) {
1559 dest->announce_rounds = params->announce_rounds;
1560 }
1561 if (params->has_announce_step) {
1562 dest->announce_step = params->announce_step;
1563 }
Max Reitz31e4c352020-08-20 17:07:23 +02001564
1565 if (params->has_block_bitmap_mapping) {
1566 dest->has_block_bitmap_mapping = true;
1567 dest->block_bitmap_mapping = params->block_bitmap_mapping;
1568 }
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001569}
1570
Juan Quintela73af8dd2017-10-05 21:30:10 +02001571static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
Peter Xu16d063b2017-07-18 11:39:04 +08001572{
1573 MigrationState *s = migrate_get_current();
1574
Markus Armbrustere87fae42017-07-18 12:57:38 +02001575 /* TODO use QAPI_CLONE() instead of duplicating it inline */
1576
Eric Blake7f375e02016-09-08 22:14:16 -05001577 if (params->has_compress_level) {
1578 s->parameters.compress_level = params->compress_level;
Liang Li85de8322015-03-23 16:32:28 +08001579 }
Peter Xu476c72a2017-07-18 11:39:05 +08001580
Eric Blake7f375e02016-09-08 22:14:16 -05001581 if (params->has_compress_threads) {
1582 s->parameters.compress_threads = params->compress_threads;
Liang Li85de8322015-03-23 16:32:28 +08001583 }
Peter Xu476c72a2017-07-18 11:39:05 +08001584
Xiao Guangrong1d588722018-08-21 16:10:20 +08001585 if (params->has_compress_wait_thread) {
1586 s->parameters.compress_wait_thread = params->compress_wait_thread;
1587 }
1588
Eric Blake7f375e02016-09-08 22:14:16 -05001589 if (params->has_decompress_threads) {
1590 s->parameters.decompress_threads = params->decompress_threads;
Liang Li85de8322015-03-23 16:32:28 +08001591 }
Peter Xu476c72a2017-07-18 11:39:05 +08001592
Keqian Zhudc14a472020-02-24 10:31:42 +08001593 if (params->has_throttle_trigger_threshold) {
1594 s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold;
1595 }
1596
Eric Blake7f375e02016-09-08 22:14:16 -05001597 if (params->has_cpu_throttle_initial) {
1598 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
Jason J. Herne1626fee2015-09-08 13:12:34 -04001599 }
Peter Xu476c72a2017-07-18 11:39:05 +08001600
Eric Blake7f375e02016-09-08 22:14:16 -05001601 if (params->has_cpu_throttle_increment) {
1602 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
Jason J. Herne1626fee2015-09-08 13:12:34 -04001603 }
Peter Xu476c72a2017-07-18 11:39:05 +08001604
Keqian Zhucbbf8182020-04-13 18:15:08 +08001605 if (params->has_cpu_throttle_tailslow) {
1606 s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow;
1607 }
1608
Eric Blake7f375e02016-09-08 22:14:16 -05001609 if (params->has_tls_creds) {
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +01001610 g_free(s->parameters.tls_creds);
Markus Armbruster01fa5592017-07-18 14:42:04 +02001611 assert(params->tls_creds->type == QTYPE_QSTRING);
1612 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +01001613 }
Peter Xu476c72a2017-07-18 11:39:05 +08001614
Eric Blake7f375e02016-09-08 22:14:16 -05001615 if (params->has_tls_hostname) {
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +01001616 g_free(s->parameters.tls_hostname);
Markus Armbruster01fa5592017-07-18 14:42:04 +02001617 assert(params->tls_hostname->type == QTYPE_QSTRING);
1618 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
Daniel P. Berrange69ef1f32016-04-27 11:05:15 +01001619 }
Peter Xu476c72a2017-07-18 11:39:05 +08001620
Daniel P. Berranged2f1d292019-02-27 14:53:24 +00001621 if (params->has_tls_authz) {
1622 g_free(s->parameters.tls_authz);
1623 assert(params->tls_authz->type == QTYPE_QSTRING);
1624 s->parameters.tls_authz = g_strdup(params->tls_authz->u.s);
1625 }
1626
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301627 if (params->has_max_bandwidth) {
1628 s->parameters.max_bandwidth = params->max_bandwidth;
Dr. David Alan Gilbertc38c1c12019-03-08 10:12:10 +00001629 if (s->to_dst_file && !migration_in_postcopy()) {
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301630 qemu_file_set_rate_limit(s->to_dst_file,
1631 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
1632 }
1633 }
Peter Xu476c72a2017-07-18 11:39:05 +08001634
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05301635 if (params->has_downtime_limit) {
1636 s->parameters.downtime_limit = params->downtime_limit;
1637 }
zhanghailiang68b53592016-10-27 14:43:01 +08001638
1639 if (params->has_x_checkpoint_delay) {
1640 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
zhanghailiang479125d2017-01-17 20:57:42 +08001641 if (migration_in_colo_state()) {
1642 colo_checkpoint_notify(s);
1643 }
zhanghailiang68b53592016-10-27 14:43:01 +08001644 }
Peter Xu476c72a2017-07-18 11:39:05 +08001645
Juan Quintela2833c592017-04-05 18:32:37 +02001646 if (params->has_block_incremental) {
1647 s->parameters.block_incremental = params->block_incremental;
1648 }
Juan Quintelacbfd6c92019-02-06 13:54:06 +01001649 if (params->has_multifd_channels) {
1650 s->parameters.multifd_channels = params->multifd_channels;
Juan Quintela4075fb12016-01-15 08:56:17 +01001651 }
Juan Quintela96eef042019-01-16 10:35:55 +01001652 if (params->has_multifd_compression) {
1653 s->parameters.multifd_compression = params->multifd_compression;
1654 }
Juan Quintela73af8dd2017-10-05 21:30:10 +02001655 if (params->has_xbzrle_cache_size) {
1656 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
1657 xbzrle_cache_resize(params->xbzrle_cache_size, errp);
1658 }
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01001659 if (params->has_max_postcopy_bandwidth) {
1660 s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth;
Dr. David Alan Gilbertc38c1c12019-03-08 10:12:10 +00001661 if (s->to_dst_file && migration_in_postcopy()) {
1662 qemu_file_set_rate_limit(s->to_dst_file,
1663 s->parameters.max_postcopy_bandwidth / XFER_LIMIT_RATIO);
1664 }
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01001665 }
Li Qiang4cbc9c72018-08-01 06:00:20 -07001666 if (params->has_max_cpu_throttle) {
1667 s->parameters.max_cpu_throttle = params->max_cpu_throttle;
1668 }
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00001669 if (params->has_announce_initial) {
1670 s->parameters.announce_initial = params->announce_initial;
1671 }
1672 if (params->has_announce_max) {
1673 s->parameters.announce_max = params->announce_max;
1674 }
1675 if (params->has_announce_rounds) {
1676 s->parameters.announce_rounds = params->announce_rounds;
1677 }
1678 if (params->has_announce_step) {
1679 s->parameters.announce_step = params->announce_step;
1680 }
Max Reitz31e4c352020-08-20 17:07:23 +02001681
1682 if (params->has_block_bitmap_mapping) {
1683 qapi_free_BitmapMigrationNodeAliasList(
1684 s->parameters.block_bitmap_mapping);
1685
1686 s->parameters.has_block_bitmap_mapping = true;
1687 s->parameters.block_bitmap_mapping =
1688 QAPI_CLONE(BitmapMigrationNodeAliasList,
1689 params->block_bitmap_mapping);
1690 }
Liang Li85de8322015-03-23 16:32:28 +08001691}
1692
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001693void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
Peter Xu476c72a2017-07-18 11:39:05 +08001694{
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001695 MigrationParameters tmp;
1696
Markus Armbruster01fa5592017-07-18 14:42:04 +02001697 /* TODO Rewrite "" to null instead */
1698 if (params->has_tls_creds
1699 && params->tls_creds->type == QTYPE_QNULL) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001700 qobject_unref(params->tls_creds->u.n);
Markus Armbruster01fa5592017-07-18 14:42:04 +02001701 params->tls_creds->type = QTYPE_QSTRING;
1702 params->tls_creds->u.s = strdup("");
1703 }
1704 /* TODO Rewrite "" to null instead */
1705 if (params->has_tls_hostname
1706 && params->tls_hostname->type == QTYPE_QNULL) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001707 qobject_unref(params->tls_hostname->u.n);
Markus Armbruster01fa5592017-07-18 14:42:04 +02001708 params->tls_hostname->type = QTYPE_QSTRING;
1709 params->tls_hostname->u.s = strdup("");
1710 }
1711
Markus Armbruster1bda8b32017-07-18 13:42:11 +02001712 migrate_params_test_apply(params, &tmp);
1713
1714 if (!migrate_params_check(&tmp, errp)) {
Peter Xu476c72a2017-07-18 11:39:05 +08001715 /* Invalid parameter */
1716 return;
1717 }
1718
Juan Quintela73af8dd2017-10-05 21:30:10 +02001719 migrate_params_apply(params, errp);
Peter Xu476c72a2017-07-18 11:39:05 +08001720}
1721
Daniel P. Berrange2594f562016-04-27 11:05:14 +01001722
Dr. David Alan Gilbert4886a1b2015-11-05 18:10:56 +00001723void qmp_migrate_start_postcopy(Error **errp)
1724{
1725 MigrationState *s = migrate_get_current();
1726
Vladimir Sementsov-Ogievskiy16b0fd32018-03-13 15:34:01 -04001727 if (!migrate_postcopy()) {
Dr. David Alan Gilberta54d3402015-11-12 11:34:44 +00001728 error_setg(errp, "Enable postcopy with migrate_set_capability before"
Dr. David Alan Gilbert4886a1b2015-11-05 18:10:56 +00001729 " the start of migration");
1730 return;
1731 }
1732
1733 if (s->state == MIGRATION_STATUS_NONE) {
1734 error_setg(errp, "Postcopy must be started after migration has been"
1735 " started");
1736 return;
1737 }
1738 /*
1739 * we don't error if migration has finished since that would be racy
1740 * with issuing this command.
1741 */
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01001742 qatomic_set(&s->start_postcopy, true);
Dr. David Alan Gilbert4886a1b2015-11-05 18:10:56 +00001743}
1744
aliguori065e2812008-11-11 16:46:33 +00001745/* shared migration helpers */
1746
zhanghailiang48781e52015-12-16 11:47:33 +00001747void migrate_set_state(int *state, int old_state, int new_state)
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +00001748{
Peter Xua31fede2017-08-30 16:32:01 +08001749 assert(new_state < MIGRATION_STATUS__MAX);
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01001750 if (qatomic_cmpxchg(state, old_state, new_state) == old_state) {
Peter Xua31fede2017-08-30 16:32:01 +08001751 trace_migrate_set_state(MigrationStatus_str(new_state));
Juan Quintelab05dc722015-07-07 14:44:05 +02001752 migrate_generate_event(new_state);
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +00001753 }
1754}
1755
Eric Blakeeaedde52020-11-12 19:13:36 -06001756static MigrationCapabilityStatus *migrate_cap_add(MigrationCapability index,
1757 bool state)
Juan Quintela2833c592017-04-05 18:32:37 +02001758{
Eric Blakeeaedde52020-11-12 19:13:36 -06001759 MigrationCapabilityStatus *cap;
Juan Quintela2833c592017-04-05 18:32:37 +02001760
Eric Blakeeaedde52020-11-12 19:13:36 -06001761 cap = g_new0(MigrationCapabilityStatus, 1);
1762 cap->capability = index;
1763 cap->state = state;
Peter Xu4e4a3d32017-07-18 11:39:09 +08001764
1765 return cap;
1766}
1767
1768void migrate_set_block_enabled(bool value, Error **errp)
1769{
Eric Blakeeaedde52020-11-12 19:13:36 -06001770 MigrationCapabilityStatusList *cap = NULL;
Peter Xu4e4a3d32017-07-18 11:39:09 +08001771
Eric Blakeeaedde52020-11-12 19:13:36 -06001772 QAPI_LIST_PREPEND(cap, migrate_cap_add(MIGRATION_CAPABILITY_BLOCK, value));
Juan Quintela2833c592017-04-05 18:32:37 +02001773 qmp_migrate_set_capabilities(cap, errp);
1774 qapi_free_MigrationCapabilityStatusList(cap);
1775}
1776
1777static void migrate_set_block_incremental(MigrationState *s, bool value)
1778{
1779 s->parameters.block_incremental = value;
1780}
1781
1782static void block_cleanup_parameters(MigrationState *s)
1783{
1784 if (s->must_remove_block_options) {
1785 /* setting to false can never fail */
1786 migrate_set_block_enabled(false, &error_abort);
1787 migrate_set_block_incremental(s, false);
1788 s->must_remove_block_options = false;
1789 }
1790}
1791
Yury Kotovfd392cf2019-04-08 14:33:43 +03001792static void migrate_fd_cleanup(MigrationState *s)
aliguori065e2812008-11-11 16:46:33 +00001793{
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +01001794 qemu_bh_delete(s->cleanup_bh);
1795 s->cleanup_bh = NULL;
1796
Peter Xu0ceccd82018-01-03 20:20:06 +08001797 qemu_savevm_state_cleanup();
1798
zhanghailiang89a02a92016-01-15 11:37:42 +08001799 if (s->to_dst_file) {
Peter Xu62df0662018-05-02 18:47:38 +08001800 QEMUFile *tmp;
Juan Quintelaf986c3d2016-01-14 16:52:55 +01001801
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +11001802 trace_migrate_fd_cleanup();
Paolo Bonzini404a7c02013-02-22 17:36:46 +01001803 qemu_mutex_unlock_iothread();
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00001804 if (s->migration_thread_running) {
1805 qemu_thread_join(&s->thread);
1806 s->migration_thread_running = false;
1807 }
Paolo Bonzini404a7c02013-02-22 17:36:46 +01001808 qemu_mutex_lock_iothread();
1809
Fei Li1398b2e2019-01-13 22:08:47 +08001810 multifd_save_cleanup();
Peter Xu62df0662018-05-02 18:47:38 +08001811 qemu_mutex_lock(&s->qemu_file_lock);
1812 tmp = s->to_dst_file;
zhanghailiang89a02a92016-01-15 11:37:42 +08001813 s->to_dst_file = NULL;
Peter Xu62df0662018-05-02 18:47:38 +08001814 qemu_mutex_unlock(&s->qemu_file_lock);
1815 /*
1816 * Close the file handle without the lock to make sure the
1817 * critical section won't block for long.
1818 */
1819 qemu_fclose(tmp);
aliguori065e2812008-11-11 16:46:33 +00001820 }
1821
Wei Yang8f8d5282019-07-17 08:53:41 +08001822 assert(!migration_is_active(s));
Paolo Bonzini7a2c1722013-02-22 17:36:09 +01001823
Liang Li94f5a432015-11-02 15:37:00 +08001824 if (s->state == MIGRATION_STATUS_CANCELLING) {
zhanghailiang48781e52015-12-16 11:47:33 +00001825 migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,
Liang Li94f5a432015-11-02 15:37:00 +08001826 MIGRATION_STATUS_CANCELLED);
Paolo Bonzini7a2c1722013-02-22 17:36:09 +01001827 }
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +01001828
Juan Quintela87db1a72017-09-05 12:50:22 +02001829 if (s->error) {
1830 /* It is used on info migrate. We can't free it */
1831 error_report_err(error_copy(s->error));
1832 }
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +01001833 notifier_list_notify(&migration_state_notifiers, s);
Juan Quintela2833c592017-04-05 18:32:37 +02001834 block_cleanup_parameters(s);
Lukas Straubb5eea992020-12-28 16:08:52 +01001835 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
aliguori065e2812008-11-11 16:46:33 +00001836}
1837
Yury Kotovfd392cf2019-04-08 14:33:43 +03001838static void migrate_fd_cleanup_schedule(MigrationState *s)
1839{
1840 /*
1841 * Ref the state for bh, because it may be called when
1842 * there're already no other refs
1843 */
1844 object_ref(OBJECT(s));
1845 qemu_bh_schedule(s->cleanup_bh);
1846}
1847
1848static void migrate_fd_cleanup_bh(void *opaque)
1849{
1850 MigrationState *s = opaque;
1851 migrate_fd_cleanup(s);
1852 object_unref(OBJECT(s));
1853}
1854
Juan Quintela87db1a72017-09-05 12:50:22 +02001855void migrate_set_error(MigrationState *s, const Error *error)
1856{
Daniel Brodsky6e8a3552020-04-03 21:21:08 -07001857 QEMU_LOCK_GUARD(&s->error_mutex);
Juan Quintela87db1a72017-09-05 12:50:22 +02001858 if (!s->error) {
1859 s->error = error_copy(error);
1860 }
Juan Quintela87db1a72017-09-05 12:50:22 +02001861}
1862
Daniel P. Berranged59ce6f2016-04-27 11:05:00 +01001863void migrate_fd_error(MigrationState *s, const Error *error)
aliguori065e2812008-11-11 16:46:33 +00001864{
Peter Maydell25174052016-10-21 18:41:45 +01001865 trace_migrate_fd_error(error_get_pretty(error));
zhanghailiang89a02a92016-01-15 11:37:42 +08001866 assert(s->to_dst_file == NULL);
zhanghailiang48781e52015-12-16 11:47:33 +00001867 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1868 MIGRATION_STATUS_FAILED);
Juan Quintela87db1a72017-09-05 12:50:22 +02001869 migrate_set_error(s, error);
Juan Quintela458cf282011-02-22 23:32:54 +01001870}
1871
Juan Quintela0edda1c2010-05-11 16:28:39 +02001872static void migrate_fd_cancel(MigrationState *s)
aliguori065e2812008-11-11 16:46:33 +00001873{
Zhanghaoyu (A)6f2b8112013-11-07 08:21:23 +00001874 int old_state ;
zhanghailiang89a02a92016-01-15 11:37:42 +08001875 QEMUFile *f = migrate_get_current()->to_dst_file;
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +11001876 trace_migrate_fd_cancel();
aliguori065e2812008-11-11 16:46:33 +00001877
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00001878 if (s->rp_state.from_dst_file) {
1879 /* shutdown the rp socket, so causing the rp thread to shutdown */
1880 qemu_file_shutdown(s->rp_state.from_dst_file);
1881 }
1882
Zhanghaoyu (A)6f2b8112013-11-07 08:21:23 +00001883 do {
1884 old_state = s->state;
Juan Quintela392d87e2020-01-21 15:39:23 +01001885 if (!migration_is_running(old_state)) {
Zhanghaoyu (A)6f2b8112013-11-07 08:21:23 +00001886 break;
1887 }
Dr. David Alan Gilberta7b36b42017-10-20 10:05:55 +01001888 /* If the migration is paused, kick it out of the pause */
1889 if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) {
1890 qemu_sem_post(&s->pause_sem);
1891 }
zhanghailiang48781e52015-12-16 11:47:33 +00001892 migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);
zhanghailiang31194732015-03-13 16:08:38 +08001893 } while (s->state != MIGRATION_STATUS_CANCELLING);
Dr. David Alan Gilberta26ba262015-01-08 11:11:32 +00001894
1895 /*
1896 * If we're unlucky the migration code might be stuck somewhere in a
1897 * send/write while the network has failed and is waiting to timeout;
1898 * if we've got shutdown(2) available then we can force it to quit.
1899 * The outgoing qemu file gets closed in migrate_fd_cleanup that is
1900 * called in a bh, so there is no race against this cancel.
1901 */
zhanghailiang31194732015-03-13 16:08:38 +08001902 if (s->state == MIGRATION_STATUS_CANCELLING && f) {
Dr. David Alan Gilberta26ba262015-01-08 11:11:32 +00001903 qemu_file_shutdown(f);
1904 }
zhanghailiang1d2acc32017-01-24 15:59:52 +08001905 if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) {
1906 Error *local_err = NULL;
1907
1908 bdrv_invalidate_cache_all(&local_err);
1909 if (local_err) {
1910 error_report_err(local_err);
1911 } else {
1912 s->block_inactive = false;
1913 }
1914 }
aliguori065e2812008-11-11 16:46:33 +00001915}
1916
Gerd Hoffmann99a0db92010-12-13 17:30:12 +01001917void add_migration_state_change_notifier(Notifier *notify)
1918{
1919 notifier_list_add(&migration_state_notifiers, notify);
1920}
1921
1922void remove_migration_state_change_notifier(Notifier *notify)
1923{
Paolo Bonzini31552522012-01-13 17:34:01 +01001924 notifier_remove(notify);
Gerd Hoffmann99a0db92010-12-13 17:30:12 +01001925}
1926
Stefan Hajnoczi02edd2e2013-07-29 15:01:58 +02001927bool migration_in_setup(MigrationState *s)
Gerd Hoffmannafe2df62011-10-25 13:50:11 +02001928{
zhanghailiang31194732015-03-13 16:08:38 +08001929 return s->state == MIGRATION_STATUS_SETUP;
Gerd Hoffmannafe2df62011-10-25 13:50:11 +02001930}
1931
Juan Quintela70736932011-02-23 00:43:59 +01001932bool migration_has_finished(MigrationState *s)
Gerd Hoffmann99a0db92010-12-13 17:30:12 +01001933{
zhanghailiang31194732015-03-13 16:08:38 +08001934 return s->state == MIGRATION_STATUS_COMPLETED;
Gerd Hoffmann99a0db92010-12-13 17:30:12 +01001935}
Juan Quintela0edda1c2010-05-11 16:28:39 +02001936
Gerd Hoffmannafe2df62011-10-25 13:50:11 +02001937bool migration_has_failed(MigrationState *s)
1938{
zhanghailiang31194732015-03-13 16:08:38 +08001939 return (s->state == MIGRATION_STATUS_CANCELLED ||
1940 s->state == MIGRATION_STATUS_FAILED);
Gerd Hoffmannafe2df62011-10-25 13:50:11 +02001941}
1942
Juan Quintela57273092017-03-20 22:25:28 +01001943bool migration_in_postcopy(void)
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +00001944{
Juan Quintela57273092017-03-20 22:25:28 +01001945 MigrationState *s = migrate_get_current();
1946
Dr. David Alan Gilbert3748fef2019-09-23 18:49:42 +01001947 switch (s->state) {
1948 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1949 case MIGRATION_STATUS_POSTCOPY_PAUSED:
1950 case MIGRATION_STATUS_POSTCOPY_RECOVER:
1951 return true;
1952 default:
1953 return false;
1954 }
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +00001955}
1956
Dr. David Alan Gilbertb82fc322016-02-22 17:17:32 +00001957bool migration_in_postcopy_after_devices(MigrationState *s)
1958{
Juan Quintela57273092017-03-20 22:25:28 +01001959 return migration_in_postcopy() && s->postcopy_after_devices;
Dr. David Alan Gilbertb82fc322016-02-22 17:17:32 +00001960}
1961
David Hildenbrand06df2e62020-06-26 09:22:33 +02001962bool migration_in_incoming_postcopy(void)
1963{
1964 PostcopyState ps = postcopy_state_get();
1965
1966 return ps >= POSTCOPY_INCOMING_DISCARD && ps < POSTCOPY_INCOMING_END;
1967}
1968
Andrey Gruzdev1a8e44a2021-04-01 12:22:24 +03001969bool migration_in_bg_snapshot(void)
1970{
1971 MigrationState *s = migrate_get_current();
1972
1973 return migrate_background_snapshot() &&
1974 migration_is_setup_or_active(s->state);
1975}
1976
Juan Quintelafab35002017-03-22 17:36:57 +01001977bool migration_is_idle(void)
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05301978{
Markus Armbrusterdaff7f02019-04-01 11:08:25 +02001979 MigrationState *s = current_migration;
1980
1981 if (!s) {
1982 return true;
1983 }
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05301984
1985 switch (s->state) {
1986 case MIGRATION_STATUS_NONE:
1987 case MIGRATION_STATUS_CANCELLED:
1988 case MIGRATION_STATUS_COMPLETED:
1989 case MIGRATION_STATUS_FAILED:
1990 return true;
1991 case MIGRATION_STATUS_SETUP:
1992 case MIGRATION_STATUS_CANCELLING:
1993 case MIGRATION_STATUS_ACTIVE:
1994 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1995 case MIGRATION_STATUS_COLO:
Dr. David Alan Gilbert31e06072017-10-20 10:05:51 +01001996 case MIGRATION_STATUS_PRE_SWITCHOVER:
1997 case MIGRATION_STATUS_DEVICE:
Jens Freimannc7e0acd2019-10-29 12:49:02 +01001998 case MIGRATION_STATUS_WAIT_UNPLUG:
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05301999 return false;
2000 case MIGRATION_STATUS__MAX:
2001 g_assert_not_reached();
2002 }
2003
2004 return false;
2005}
2006
Wei Yang8f8d5282019-07-17 08:53:41 +08002007bool migration_is_active(MigrationState *s)
2008{
2009 return (s->state == MIGRATION_STATUS_ACTIVE ||
2010 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
2011}
2012
Peter Xu3e0c8052018-02-08 18:31:15 +08002013void migrate_init(MigrationState *s)
Juan Quintela0edda1c2010-05-11 16:28:39 +02002014{
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002015 /*
2016 * Reinitialise all migration state, except
2017 * parameters/capabilities that the user set, and
2018 * locks.
2019 */
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002020 s->cleanup_bh = 0;
Andrey Gruzdev85182782021-01-29 13:14:06 +03002021 s->vm_start_bh = 0;
zhanghailiang89a02a92016-01-15 11:37:42 +08002022 s->to_dst_file = NULL;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002023 s->state = MIGRATION_STATUS_NONE;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002024 s->rp_state.from_dst_file = NULL;
2025 s->rp_state.error = false;
2026 s->mbps = 0.0;
Xiao Guangrongaecbfe92019-01-11 14:37:30 +08002027 s->pages_per_second = 0.0;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002028 s->downtime = 0;
2029 s->expected_downtime = 0;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002030 s->setup_time = 0;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002031 s->start_postcopy = false;
Dr. David Alan Gilbertb82fc322016-02-22 17:17:32 +00002032 s->postcopy_after_devices = false;
Dr. David Alan Gilbert389775d2015-11-12 15:38:27 +00002033 s->migration_thread_running = false;
Daniel P. Berranged59ce6f2016-04-27 11:05:00 +01002034 error_free(s->error);
2035 s->error = NULL;
Chuan Zhengd8053e72020-09-15 11:03:57 +08002036 s->hostname = NULL;
Juan Quintela1299c632011-11-09 21:29:01 +01002037
zhanghailiang48781e52015-12-16 11:47:33 +00002038 migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);
Juan Quintela0edda1c2010-05-11 16:28:39 +02002039
Peter Xu4af246a2018-01-03 20:20:08 +08002040 s->start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2041 s->total_time = 0;
Peter Xu7287cbd2018-01-03 20:20:09 +08002042 s->vm_was_running = false;
Peter Xub15df1a2018-01-03 20:20:13 +08002043 s->iteration_initial_bytes = 0;
2044 s->threshold_size = 0;
Juan Quintela0edda1c2010-05-11 16:28:39 +02002045}
Juan Quintelacab30142011-02-22 23:54:21 +01002046
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05302047int migrate_add_blocker(Error *reason, Error **errp)
Anthony Liguorifa2756b2011-11-14 15:09:43 -06002048{
Markus Armbruster811f8652019-04-01 11:08:24 +02002049 if (only_migratable) {
Markus Armbruster4b576642018-10-17 10:26:25 +02002050 error_propagate_prepend(errp, error_copy(reason),
2051 "disallowing migration blocker "
Greg Kurzb6eca812019-05-16 12:58:05 +02002052 "(--only-migratable) for: ");
Ashijeet Acharyab67b8c32017-01-16 17:01:54 +05302053 return -EACCES;
2054 }
2055
Juan Quintelafab35002017-03-22 17:36:57 +01002056 if (migration_is_idle()) {
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05302057 migration_blockers = g_slist_prepend(migration_blockers, reason);
2058 return 0;
2059 }
2060
Markus Armbruster4b576642018-10-17 10:26:25 +02002061 error_propagate_prepend(errp, error_copy(reason),
2062 "disallowing migration blocker "
2063 "(migration in progress) for: ");
Ashijeet Acharyafe44dc92017-01-16 17:01:53 +05302064 return -EBUSY;
Anthony Liguorifa2756b2011-11-14 15:09:43 -06002065}
2066
2067void migrate_del_blocker(Error *reason)
2068{
2069 migration_blockers = g_slist_remove(migration_blockers, reason);
2070}
2071
Dr. David Alan Gilbertbf1ae1f2015-02-19 11:40:28 +00002072void qmp_migrate_incoming(const char *uri, Error **errp)
2073{
2074 Error *local_err = NULL;
Dr. David Alan Gilbert4debb5f2015-02-26 14:54:41 +00002075 static bool once = true;
Dr. David Alan Gilbertbf1ae1f2015-02-19 11:40:28 +00002076
Dr. David Alan Gilbert4debb5f2015-02-26 14:54:41 +00002077 if (!once) {
2078 error_setg(errp, "The incoming migration has already been started");
Yury Kotov603d5a42019-11-13 20:53:25 +03002079 return;
Dr. David Alan Gilbert4debb5f2015-02-26 14:54:41 +00002080 }
Paolo Bonzinie69d50d2020-10-27 04:22:57 -04002081 if (!runstate_check(RUN_STATE_INMIGRATE)) {
2082 error_setg(errp, "'-incoming' was not specified on the command line");
2083 return;
2084 }
Dr. David Alan Gilbertbf1ae1f2015-02-19 11:40:28 +00002085
2086 qemu_start_incoming_migration(uri, &local_err);
2087
2088 if (local_err) {
2089 error_propagate(errp, local_err);
2090 return;
2091 }
2092
Dr. David Alan Gilbert4debb5f2015-02-26 14:54:41 +00002093 once = false;
Dr. David Alan Gilbertbf1ae1f2015-02-19 11:40:28 +00002094}
2095
Peter Xu02affd42018-05-02 18:47:36 +08002096void qmp_migrate_recover(const char *uri, Error **errp)
2097{
2098 MigrationIncomingState *mis = migration_incoming_get_current();
2099
2100 if (mis->state != MIGRATION_STATUS_POSTCOPY_PAUSED) {
2101 error_setg(errp, "Migrate recover can only be run "
2102 "when postcopy is paused.");
2103 return;
2104 }
2105
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01002106 if (qatomic_cmpxchg(&mis->postcopy_recover_triggered,
Peter Xu02affd42018-05-02 18:47:36 +08002107 false, true) == true) {
2108 error_setg(errp, "Migrate recovery is triggered already");
2109 return;
2110 }
2111
2112 /*
2113 * Note that this call will never start a real migration; it will
2114 * only re-setup the migration stream and poke existing migration
2115 * to continue using that newly established channel.
2116 */
Lukas Straubb5eea992020-12-28 16:08:52 +01002117 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
Peter Xu02affd42018-05-02 18:47:36 +08002118 qemu_start_incoming_migration(uri, errp);
2119}
2120
Peter Xubfbf89c2018-05-02 18:47:39 +08002121void qmp_migrate_pause(Error **errp)
2122{
2123 MigrationState *ms = migrate_get_current();
2124 MigrationIncomingState *mis = migration_incoming_get_current();
2125 int ret;
2126
2127 if (ms->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2128 /* Source side, during postcopy */
2129 qemu_mutex_lock(&ms->qemu_file_lock);
2130 ret = qemu_file_shutdown(ms->to_dst_file);
2131 qemu_mutex_unlock(&ms->qemu_file_lock);
2132 if (ret) {
2133 error_setg(errp, "Failed to pause source migration");
2134 }
2135 return;
2136 }
2137
2138 if (mis->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2139 ret = qemu_file_shutdown(mis->from_src_file);
2140 if (ret) {
2141 error_setg(errp, "Failed to pause destination migration");
2142 }
2143 return;
2144 }
2145
2146 error_setg(errp, "migrate-pause is currently only supported "
2147 "during postcopy-active state");
2148}
2149
Greg Kurz24f39022016-05-04 21:44:19 +02002150bool migration_is_blocked(Error **errp)
2151{
2152 if (qemu_savevm_state_blocked(errp)) {
2153 return true;
2154 }
2155
2156 if (migration_blockers) {
Eduardo Habkost250561e2017-06-08 10:39:05 -03002157 error_propagate(errp, error_copy(migration_blockers->data));
Greg Kurz24f39022016-05-04 21:44:19 +02002158 return true;
2159 }
2160
2161 return false;
2162}
2163
Peter Xud3e35b82018-05-02 18:47:24 +08002164/* Returns true if continue to migrate, or false if error detected */
2165static bool migrate_prepare(MigrationState *s, bool blk, bool blk_inc,
2166 bool resume, Error **errp)
2167{
2168 Error *local_err = NULL;
2169
2170 if (resume) {
2171 if (s->state != MIGRATION_STATUS_POSTCOPY_PAUSED) {
2172 error_setg(errp, "Cannot resume if there is no "
2173 "paused migration");
2174 return false;
2175 }
Peter Xu97ca2112018-07-23 20:33:03 +08002176
2177 /*
2178 * Postcopy recovery won't work well with release-ram
2179 * capability since release-ram will drop the page buffer as
2180 * long as the page is put into the send buffer. So if there
2181 * is a network failure happened, any page buffers that have
2182 * not yet reached the destination VM but have already been
2183 * sent from the source VM will be lost forever. Let's refuse
2184 * the client from resuming such a postcopy migration.
2185 * Luckily release-ram was designed to only be used when src
2186 * and destination VMs are on the same host, so it should be
2187 * fine.
2188 */
2189 if (migrate_release_ram()) {
2190 error_setg(errp, "Postcopy recovery cannot work "
2191 "when release-ram capability is set");
2192 return false;
2193 }
2194
Peter Xud3e35b82018-05-02 18:47:24 +08002195 /* This is a resume, skip init status */
2196 return true;
2197 }
2198
Juan Quintela392d87e2020-01-21 15:39:23 +01002199 if (migration_is_running(s->state)) {
Peter Xud3e35b82018-05-02 18:47:24 +08002200 error_setg(errp, QERR_MIGRATION_ACTIVE);
2201 return false;
2202 }
2203
2204 if (runstate_check(RUN_STATE_INMIGRATE)) {
2205 error_setg(errp, "Guest is waiting for an incoming migration");
2206 return false;
2207 }
2208
Tuguoyi36d0fe62020-12-08 01:46:25 +00002209 if (runstate_check(RUN_STATE_POSTMIGRATE)) {
2210 error_setg(errp, "Can't migrate the vm that was paused due to "
2211 "previous migration");
2212 return false;
2213 }
2214
Peter Xud3e35b82018-05-02 18:47:24 +08002215 if (migration_is_blocked(errp)) {
2216 return false;
2217 }
2218
2219 if (blk || blk_inc) {
Rao, Lei3ba02442021-06-08 16:23:28 +08002220 if (migrate_colo_enabled()) {
2221 error_setg(errp, "No disk migration is required in COLO mode");
2222 return false;
2223 }
Peter Xud3e35b82018-05-02 18:47:24 +08002224 if (migrate_use_block() || migrate_use_block_incremental()) {
2225 error_setg(errp, "Command options are incompatible with "
2226 "current migration capabilities");
2227 return false;
2228 }
2229 migrate_set_block_enabled(true, &local_err);
2230 if (local_err) {
2231 error_propagate(errp, local_err);
2232 return false;
2233 }
2234 s->must_remove_block_options = true;
2235 }
2236
2237 if (blk_inc) {
2238 migrate_set_block_incremental(s, true);
2239 }
2240
2241 migrate_init(s);
Ivan Ren87f3bd82019-08-02 18:18:41 +08002242 /*
2243 * set ram_counters memory to zero for a
2244 * new migration
2245 */
2246 memset(&ram_counters, 0, sizeof(ram_counters));
Peter Xud3e35b82018-05-02 18:47:24 +08002247
2248 return true;
2249}
2250
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02002251void qmp_migrate(const char *uri, bool has_blk, bool blk,
2252 bool has_inc, bool inc, bool has_detach, bool detach,
Peter Xu7a4da282018-05-02 18:47:23 +08002253 bool has_resume, bool resume, Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +01002254{
Paolo Bonzinibe7059c2012-10-03 14:34:33 +02002255 Error *local_err = NULL;
Juan Quintela17549e82011-10-05 13:50:43 +02002256 MigrationState *s = migrate_get_current();
Longpeng(Mike)d658f652020-08-06 15:40:29 +08002257 const char *p = NULL;
Juan Quintelacab30142011-02-22 23:54:21 +01002258
Peter Xud3e35b82018-05-02 18:47:24 +08002259 if (!migrate_prepare(s, has_blk && blk, has_inc && inc,
2260 has_resume && resume, errp)) {
2261 /* Error detected, put into errp */
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02002262 return;
Juan Quintelacab30142011-02-22 23:54:21 +01002263 }
Juan Quintelacab30142011-02-22 23:54:21 +01002264
Lukas Straubb5eea992020-12-28 16:08:52 +01002265 if (!(has_resume && resume)) {
2266 if (!yank_register_instance(MIGRATION_YANK_INSTANCE, errp)) {
2267 return;
2268 }
2269 }
2270
Longpeng(Mike)d658f652020-08-06 15:40:29 +08002271 if (strstart(uri, "tcp:", &p) ||
Longpeng(Mike)9ba3b2b2020-08-06 15:40:30 +08002272 strstart(uri, "unix:", NULL) ||
2273 strstart(uri, "vsock:", NULL)) {
Longpeng(Mike)d658f652020-08-06 15:40:29 +08002274 socket_start_outgoing_migration(s, p ? p : uri, &local_err);
Michael R. Hines2da776d2013-07-22 10:01:54 -04002275#ifdef CONFIG_RDMA
Michael R. Hines41310c62013-12-19 04:52:01 +08002276 } else if (strstart(uri, "rdma:", &p)) {
Michael R. Hines2da776d2013-07-22 10:01:54 -04002277 rdma_start_outgoing_migration(s, p, &local_err);
2278#endif
Juan Quintelacab30142011-02-22 23:54:21 +01002279 } else if (strstart(uri, "exec:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +02002280 exec_start_outgoing_migration(s, p, &local_err);
Juan Quintelacab30142011-02-22 23:54:21 +01002281 } else if (strstart(uri, "fd:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +02002282 fd_start_outgoing_migration(s, p, &local_err);
Juan Quintelacab30142011-02-22 23:54:21 +01002283 } else {
Lukas Straubb5eea992020-12-28 16:08:52 +01002284 if (!(has_resume && resume)) {
2285 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
2286 }
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002287 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",
2288 "a valid migration protocol");
zhanghailiang48781e52015-12-16 11:47:33 +00002289 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2290 MIGRATION_STATUS_FAILED);
Dr. David Alan Gilbert09576e72018-03-16 20:21:14 +00002291 block_cleanup_parameters(s);
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02002292 return;
Juan Quintelacab30142011-02-22 23:54:21 +01002293 }
2294
Paolo Bonzinif37afb52012-10-02 10:02:46 +02002295 if (local_err) {
Lukas Straubb5eea992020-12-28 16:08:52 +01002296 if (!(has_resume && resume)) {
2297 yank_unregister_instance(MIGRATION_YANK_INSTANCE);
2298 }
Daniel P. Berranged59ce6f2016-04-27 11:05:00 +01002299 migrate_fd_error(s, local_err);
Paolo Bonzinif37afb52012-10-02 10:02:46 +02002300 error_propagate(errp, local_err);
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02002301 return;
Juan Quintela1299c632011-11-09 21:29:01 +01002302 }
Juan Quintelacab30142011-02-22 23:54:21 +01002303}
2304
Luiz Capitulino6cdedb02011-11-27 22:54:09 -02002305void qmp_migrate_cancel(Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +01002306{
David Hildenbrandc7c0e722021-04-29 13:27:02 +02002307 migration_cancel();
Juan Quintelacab30142011-02-22 23:54:21 +01002308}
2309
Dr. David Alan Gilbert89cfc022017-10-20 10:05:53 +01002310void qmp_migrate_continue(MigrationStatus state, Error **errp)
2311{
2312 MigrationState *s = migrate_get_current();
2313 if (s->state != state) {
2314 error_setg(errp, "Migration not in expected state: %s",
2315 MigrationStatus_str(s->state));
2316 return;
2317 }
2318 qemu_sem_post(&s->pause_sem);
2319}
2320
Pavel Butsykin53f09a12017-02-03 18:23:20 +03002321bool migrate_release_ram(void)
2322{
2323 MigrationState *s;
2324
2325 s = migrate_get_current();
2326
2327 return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
2328}
2329
Dr. David Alan Gilbert53dd3702015-11-05 18:10:51 +00002330bool migrate_postcopy_ram(void)
2331{
2332 MigrationState *s;
2333
2334 s = migrate_get_current();
2335
Dr. David Alan Gilbert32c3db52016-03-11 09:53:36 +00002336 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
Dr. David Alan Gilbert53dd3702015-11-05 18:10:51 +00002337}
2338
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03002339bool migrate_postcopy(void)
2340{
Vladimir Sementsov-Ogievskiydd6bb912018-03-13 15:34:00 -04002341 return migrate_postcopy_ram() || migrate_dirty_bitmaps();
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03002342}
2343
Chegu Vinodbde1e2e2013-06-24 03:49:42 -06002344bool migrate_auto_converge(void)
2345{
2346 MigrationState *s;
2347
2348 s = migrate_get_current();
2349
2350 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
2351}
2352
Peter Lieven323004a2013-07-18 09:48:50 +02002353bool migrate_zero_blocks(void)
2354{
2355 MigrationState *s;
2356
2357 s = migrate_get_current();
2358
2359 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
2360}
2361
Alexey Perevalovf22f9282018-03-22 21:17:22 +03002362bool migrate_postcopy_blocktime(void)
2363{
2364 MigrationState *s;
2365
2366 s = migrate_get_current();
2367
2368 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME];
2369}
2370
Liang Li8706d2d2015-03-23 16:32:17 +08002371bool migrate_use_compression(void)
2372{
Liang Lidde4e692015-03-23 16:32:26 +08002373 MigrationState *s;
2374
2375 s = migrate_get_current();
2376
2377 return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS];
Liang Li8706d2d2015-03-23 16:32:17 +08002378}
2379
2380int migrate_compress_level(void)
2381{
2382 MigrationState *s;
2383
2384 s = migrate_get_current();
2385
Daniel P. Berrange2594f562016-04-27 11:05:14 +01002386 return s->parameters.compress_level;
Liang Li8706d2d2015-03-23 16:32:17 +08002387}
2388
2389int migrate_compress_threads(void)
2390{
2391 MigrationState *s;
2392
2393 s = migrate_get_current();
2394
Daniel P. Berrange2594f562016-04-27 11:05:14 +01002395 return s->parameters.compress_threads;
Liang Li8706d2d2015-03-23 16:32:17 +08002396}
2397
Xiao Guangrong1d588722018-08-21 16:10:20 +08002398int migrate_compress_wait_thread(void)
2399{
2400 MigrationState *s;
2401
2402 s = migrate_get_current();
2403
2404 return s->parameters.compress_wait_thread;
2405}
2406
Liang Li3fcb38c2015-03-23 16:32:18 +08002407int migrate_decompress_threads(void)
2408{
2409 MigrationState *s;
2410
2411 s = migrate_get_current();
2412
Daniel P. Berrange2594f562016-04-27 11:05:14 +01002413 return s->parameters.decompress_threads;
Liang Li3fcb38c2015-03-23 16:32:18 +08002414}
2415
Vladimir Sementsov-Ogievskiy55efc8c2018-03-13 15:34:00 -04002416bool migrate_dirty_bitmaps(void)
2417{
2418 MigrationState *s;
2419
2420 s = migrate_get_current();
2421
2422 return s->enabled_capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS];
2423}
2424
Yury Kotov18269062019-02-15 20:45:45 +03002425bool migrate_ignore_shared(void)
2426{
2427 MigrationState *s;
2428
2429 s = migrate_get_current();
2430
2431 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED];
2432}
2433
Yury Kotovb9d68df2019-09-03 19:22:44 +03002434bool migrate_validate_uuid(void)
2435{
2436 MigrationState *s;
2437
2438 s = migrate_get_current();
2439
2440 return s->enabled_capabilities[MIGRATION_CAPABILITY_VALIDATE_UUID];
2441}
2442
Juan Quintelab05dc722015-07-07 14:44:05 +02002443bool migrate_use_events(void)
2444{
2445 MigrationState *s;
2446
2447 s = migrate_get_current();
2448
2449 return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS];
2450}
2451
Juan Quintela30126bb2016-01-14 12:23:00 +01002452bool migrate_use_multifd(void)
2453{
2454 MigrationState *s;
2455
2456 s = migrate_get_current();
2457
Juan Quintelacbfd6c92019-02-06 13:54:06 +01002458 return s->enabled_capabilities[MIGRATION_CAPABILITY_MULTIFD];
Juan Quintela30126bb2016-01-14 12:23:00 +01002459}
2460
Dr. David Alan Gilbert93fbd032017-10-20 10:05:50 +01002461bool migrate_pause_before_switchover(void)
2462{
2463 MigrationState *s;
2464
2465 s = migrate_get_current();
2466
2467 return s->enabled_capabilities[
2468 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
2469}
2470
Juan Quintela4075fb12016-01-15 08:56:17 +01002471int migrate_multifd_channels(void)
2472{
2473 MigrationState *s;
2474
2475 s = migrate_get_current();
2476
Juan Quintelacbfd6c92019-02-06 13:54:06 +01002477 return s->parameters.multifd_channels;
Juan Quintela4075fb12016-01-15 08:56:17 +01002478}
2479
Juan Quintelaab7cbb02019-05-15 13:37:46 +02002480MultiFDCompression migrate_multifd_compression(void)
2481{
2482 MigrationState *s;
2483
2484 s = migrate_get_current();
2485
2486 return s->parameters.multifd_compression;
2487}
2488
Juan Quintela9004db42020-01-23 17:08:52 +01002489int migrate_multifd_zlib_level(void)
2490{
2491 MigrationState *s;
2492
2493 s = migrate_get_current();
2494
2495 return s->parameters.multifd_zlib_level;
2496}
2497
Juan Quintela6a9ad152020-01-23 17:41:36 +01002498int migrate_multifd_zstd_level(void)
2499{
2500 MigrationState *s;
2501
2502 s = migrate_get_current();
2503
2504 return s->parameters.multifd_zstd_level;
2505}
2506
Orit Wasserman17ad9b32012-08-06 21:42:53 +03002507int migrate_use_xbzrle(void)
2508{
2509 MigrationState *s;
2510
2511 s = migrate_get_current();
2512
2513 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
2514}
2515
Markus Armbruster8b9407a2021-02-02 15:17:32 +01002516uint64_t migrate_xbzrle_cache_size(void)
Orit Wasserman17ad9b32012-08-06 21:42:53 +03002517{
2518 MigrationState *s;
2519
2520 s = migrate_get_current();
2521
Juan Quintela73af8dd2017-10-05 21:30:10 +02002522 return s->parameters.xbzrle_cache_size;
Orit Wasserman17ad9b32012-08-06 21:42:53 +03002523}
Juan Quintela0d82d0e2012-10-03 14:18:33 +02002524
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01002525static int64_t migrate_max_postcopy_bandwidth(void)
2526{
2527 MigrationState *s;
2528
2529 s = migrate_get_current();
2530
2531 return s->parameters.max_postcopy_bandwidth;
2532}
2533
Juan Quintela2833c592017-04-05 18:32:37 +02002534bool migrate_use_block(void)
2535{
2536 MigrationState *s;
2537
2538 s = migrate_get_current();
2539
2540 return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK];
2541}
2542
Peter Xuc788ada2017-06-26 18:28:55 +08002543bool migrate_use_return_path(void)
2544{
2545 MigrationState *s;
2546
2547 s = migrate_get_current();
2548
2549 return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
2550}
2551
Juan Quintela2833c592017-04-05 18:32:37 +02002552bool migrate_use_block_incremental(void)
2553{
2554 MigrationState *s;
2555
2556 s = migrate_get_current();
2557
2558 return s->parameters.block_incremental;
2559}
2560
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +03002561bool migrate_background_snapshot(void)
2562{
2563 MigrationState *s;
2564
2565 s = migrate_get_current();
2566
2567 return s->enabled_capabilities[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT];
2568}
2569
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002570/* migration thread support */
2571/*
2572 * Something bad happened to the RP stream, mark an error
2573 * The caller shall print or trace something to indicate why
2574 */
2575static void mark_source_rp_bad(MigrationState *s)
2576{
2577 s->rp_state.error = true;
2578}
2579
2580static struct rp_cmd_args {
2581 ssize_t len; /* -1 = variable */
2582 const char *name;
2583} rp_cmd_args[] = {
2584 [MIG_RP_MSG_INVALID] = { .len = -1, .name = "INVALID" },
2585 [MIG_RP_MSG_SHUT] = { .len = 4, .name = "SHUT" },
2586 [MIG_RP_MSG_PONG] = { .len = 4, .name = "PONG" },
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002587 [MIG_RP_MSG_REQ_PAGES] = { .len = 12, .name = "REQ_PAGES" },
2588 [MIG_RP_MSG_REQ_PAGES_ID] = { .len = -1, .name = "REQ_PAGES_ID" },
Peter Xua335deb2018-05-02 18:47:28 +08002589 [MIG_RP_MSG_RECV_BITMAP] = { .len = -1, .name = "RECV_BITMAP" },
Peter Xu13955b82018-05-02 18:47:30 +08002590 [MIG_RP_MSG_RESUME_ACK] = { .len = 4, .name = "RESUME_ACK" },
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002591 [MIG_RP_MSG_MAX] = { .len = -1, .name = "MAX" },
2592};
2593
2594/*
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002595 * Process a request for pages received on the return path,
2596 * We're allowed to send more than requested (e.g. to round to our page size)
2597 * and we don't need to send pages that have already been sent.
2598 */
2599static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname,
2600 ram_addr_t start, size_t len)
2601{
Wei Yang038adc22019-10-13 10:11:45 +08002602 long our_host_ps = qemu_real_host_page_size;
Dr. David Alan Gilbert6c595cd2015-11-05 18:11:08 +00002603
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002604 trace_migrate_handle_rp_req_pages(rbname, start, len);
Dr. David Alan Gilbert6c595cd2015-11-05 18:11:08 +00002605
2606 /*
2607 * Since we currently insist on matching page sizes, just sanity check
2608 * we're being asked for whole host pages.
2609 */
Bihong Yu395cb452020-10-20 11:10:43 +08002610 if (start & (our_host_ps - 1) ||
2611 (len & (our_host_ps - 1))) {
Dr. David Alan Gilbert6c595cd2015-11-05 18:11:08 +00002612 error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT
2613 " len: %zd", __func__, start, len);
2614 mark_source_rp_bad(ms);
2615 return;
2616 }
2617
Juan Quintela96506892017-03-14 18:41:03 +01002618 if (ram_save_queue_pages(rbname, start, len)) {
Dr. David Alan Gilbert6c595cd2015-11-05 18:11:08 +00002619 mark_source_rp_bad(ms);
2620 }
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002621}
2622
Peter Xu14b17422018-05-02 18:47:21 +08002623/* Return true to retry, false to quit */
2624static bool postcopy_pause_return_path_thread(MigrationState *s)
2625{
2626 trace_postcopy_pause_return_path();
2627
2628 qemu_sem_wait(&s->postcopy_pause_rp_sem);
2629
2630 trace_postcopy_pause_return_path_continued();
2631
2632 return true;
2633}
2634
Peter Xua335deb2018-05-02 18:47:28 +08002635static int migrate_handle_rp_recv_bitmap(MigrationState *s, char *block_name)
2636{
2637 RAMBlock *block = qemu_ram_block_by_name(block_name);
2638
2639 if (!block) {
2640 error_report("%s: invalid block name '%s'", __func__, block_name);
2641 return -EINVAL;
2642 }
2643
2644 /* Fetch the received bitmap and refresh the dirty bitmap */
2645 return ram_dirty_bitmap_reload(s, block);
2646}
2647
Peter Xu13955b82018-05-02 18:47:30 +08002648static int migrate_handle_rp_resume_ack(MigrationState *s, uint32_t value)
2649{
2650 trace_source_return_path_thread_resume_ack(value);
2651
2652 if (value != MIGRATION_RESUME_ACK_VALUE) {
2653 error_report("%s: illegal resume_ack value %"PRIu32,
2654 __func__, value);
2655 return -1;
2656 }
2657
2658 /* Now both sides are active. */
2659 migrate_set_state(&s->state, MIGRATION_STATUS_POSTCOPY_RECOVER,
2660 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2661
Peter Xu94190692018-05-02 18:47:34 +08002662 /* Notify send thread that time to continue send pages */
2663 qemu_sem_post(&s->rp_state.rp_sem);
Peter Xu13955b82018-05-02 18:47:30 +08002664
2665 return 0;
2666}
2667
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002668/*
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002669 * Handles messages sent on the return path towards the source VM
2670 *
2671 */
2672static void *source_return_path_thread(void *opaque)
2673{
2674 MigrationState *ms = opaque;
2675 QEMUFile *rp = ms->rp_state.from_dst_file;
2676 uint16_t header_len, header_type;
Peter Xu568b01c2016-03-09 14:12:12 +08002677 uint8_t buf[512];
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002678 uint32_t tmp32, sibling_error;
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002679 ram_addr_t start = 0; /* =0 to silence warning */
2680 size_t len = 0, expected_len;
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002681 int res;
2682
2683 trace_source_return_path_thread_entry();
Lidong Chen74637e62018-08-06 21:29:29 +08002684 rcu_register_thread();
Peter Xu14b17422018-05-02 18:47:21 +08002685
2686retry:
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002687 while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
2688 migration_is_setup_or_active(ms->state)) {
2689 trace_source_return_path_thread_loop_top();
2690 header_type = qemu_get_be16(rp);
2691 header_len = qemu_get_be16(rp);
2692
Peter Xu7a9ddfb2018-02-08 18:31:05 +08002693 if (qemu_file_get_error(rp)) {
2694 mark_source_rp_bad(ms);
2695 goto out;
2696 }
2697
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002698 if (header_type >= MIG_RP_MSG_MAX ||
2699 header_type == MIG_RP_MSG_INVALID) {
2700 error_report("RP: Received invalid message 0x%04x length 0x%04x",
Mao Zhongyied8b2822020-03-28 01:19:08 +08002701 header_type, header_len);
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002702 mark_source_rp_bad(ms);
2703 goto out;
2704 }
2705
2706 if ((rp_cmd_args[header_type].len != -1 &&
2707 header_len != rp_cmd_args[header_type].len) ||
Peter Xu568b01c2016-03-09 14:12:12 +08002708 header_len > sizeof(buf)) {
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002709 error_report("RP: Received '%s' message (0x%04x) with"
Mao Zhongyied8b2822020-03-28 01:19:08 +08002710 "incorrect length %d expecting %zu",
2711 rp_cmd_args[header_type].name, header_type, header_len,
2712 (size_t)rp_cmd_args[header_type].len);
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002713 mark_source_rp_bad(ms);
2714 goto out;
2715 }
2716
2717 /* We know we've got a valid header by this point */
2718 res = qemu_get_buffer(rp, buf, header_len);
2719 if (res != header_len) {
2720 error_report("RP: Failed reading data for message 0x%04x"
2721 " read %d expected %d",
2722 header_type, res, header_len);
2723 mark_source_rp_bad(ms);
2724 goto out;
2725 }
2726
2727 /* OK, we have the message and the data */
2728 switch (header_type) {
2729 case MIG_RP_MSG_SHUT:
Peter Maydell4d885132016-06-10 17:09:22 +01002730 sibling_error = ldl_be_p(buf);
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002731 trace_source_return_path_thread_shut(sibling_error);
2732 if (sibling_error) {
2733 error_report("RP: Sibling indicated error %d", sibling_error);
2734 mark_source_rp_bad(ms);
2735 }
2736 /*
2737 * We'll let the main thread deal with closing the RP
2738 * we could do a shutdown(2) on it, but we're the only user
2739 * anyway, so there's nothing gained.
2740 */
2741 goto out;
2742
2743 case MIG_RP_MSG_PONG:
Peter Maydell4d885132016-06-10 17:09:22 +01002744 tmp32 = ldl_be_p(buf);
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002745 trace_source_return_path_thread_pong(tmp32);
2746 break;
2747
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002748 case MIG_RP_MSG_REQ_PAGES:
Peter Maydell4d885132016-06-10 17:09:22 +01002749 start = ldq_be_p(buf);
2750 len = ldl_be_p(buf + 8);
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002751 migrate_handle_rp_req_pages(ms, NULL, start, len);
2752 break;
2753
2754 case MIG_RP_MSG_REQ_PAGES_ID:
2755 expected_len = 12 + 1; /* header + termination */
2756
2757 if (header_len >= expected_len) {
Peter Maydell4d885132016-06-10 17:09:22 +01002758 start = ldq_be_p(buf);
2759 len = ldl_be_p(buf + 8);
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002760 /* Now we expect an idstr */
2761 tmp32 = buf[12]; /* Length of the following idstr */
2762 buf[13 + tmp32] = '\0';
2763 expected_len += tmp32;
2764 }
2765 if (header_len != expected_len) {
2766 error_report("RP: Req_Page_id with length %d expecting %zd",
Mao Zhongyied8b2822020-03-28 01:19:08 +08002767 header_len, expected_len);
Dr. David Alan Gilbert1e2d90e2015-11-05 18:11:07 +00002768 mark_source_rp_bad(ms);
2769 goto out;
2770 }
2771 migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len);
2772 break;
2773
Peter Xua335deb2018-05-02 18:47:28 +08002774 case MIG_RP_MSG_RECV_BITMAP:
2775 if (header_len < 1) {
2776 error_report("%s: missing block name", __func__);
2777 mark_source_rp_bad(ms);
2778 goto out;
2779 }
2780 /* Format: len (1B) + idstr (<255B). This ends the idstr. */
2781 buf[buf[0] + 1] = '\0';
2782 if (migrate_handle_rp_recv_bitmap(ms, (char *)(buf + 1))) {
2783 mark_source_rp_bad(ms);
2784 goto out;
2785 }
2786 break;
2787
Peter Xu13955b82018-05-02 18:47:30 +08002788 case MIG_RP_MSG_RESUME_ACK:
2789 tmp32 = ldl_be_p(buf);
2790 if (migrate_handle_rp_resume_ack(ms, tmp32)) {
2791 mark_source_rp_bad(ms);
2792 goto out;
2793 }
2794 break;
2795
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002796 default:
2797 break;
2798 }
2799 }
Peter Xu14b17422018-05-02 18:47:21 +08002800
2801out:
2802 res = qemu_file_get_error(rp);
2803 if (res) {
Dr. David Alan Gilbertfb14a422019-10-07 11:35:07 +01002804 if (res == -EIO && migration_in_postcopy()) {
Peter Xu14b17422018-05-02 18:47:21 +08002805 /*
2806 * Maybe there is something we can do: it looks like a
2807 * network down issue, and we pause for a recovery.
2808 */
2809 if (postcopy_pause_return_path_thread(ms)) {
2810 /* Reload rp, reset the rest */
Marc-André Lureau0284a2a2018-09-25 13:22:45 +04002811 if (rp != ms->rp_state.from_dst_file) {
2812 qemu_fclose(rp);
2813 rp = ms->rp_state.from_dst_file;
2814 }
Peter Xu14b17422018-05-02 18:47:21 +08002815 ms->rp_state.error = false;
2816 goto retry;
2817 }
2818 }
2819
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002820 trace_source_return_path_thread_bad_end();
2821 mark_source_rp_bad(ms);
2822 }
2823
2824 trace_source_return_path_thread_end();
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002825 ms->rp_state.from_dst_file = NULL;
2826 qemu_fclose(rp);
Lidong Chen74637e62018-08-06 21:29:29 +08002827 rcu_unregister_thread();
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002828 return NULL;
2829}
2830
Peter Xud3e35b82018-05-02 18:47:24 +08002831static int open_return_path_on_source(MigrationState *ms,
2832 bool create_thread)
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002833{
2834
zhanghailiang89a02a92016-01-15 11:37:42 +08002835 ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002836 if (!ms->rp_state.from_dst_file) {
2837 return -1;
2838 }
2839
2840 trace_open_return_path_on_source();
Peter Xud3e35b82018-05-02 18:47:24 +08002841
2842 if (!create_thread) {
2843 /* We're done */
2844 return 0;
2845 }
2846
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002847 qemu_thread_create(&ms->rp_state.rp_thread, "return path",
2848 source_return_path_thread, ms, QEMU_THREAD_JOINABLE);
2849
2850 trace_open_return_path_on_source_continue();
2851
2852 return 0;
2853}
2854
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002855/* Returns 0 if the RP was ok, otherwise there was an error on the RP */
2856static int await_return_path_close_on_source(MigrationState *ms)
2857{
2858 /*
2859 * If this is a normal exit then the destination will send a SHUT and the
2860 * rp_thread will exit, however if there's an error we need to cause
2861 * it to exit.
2862 */
zhanghailiang89a02a92016-01-15 11:37:42 +08002863 if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00002864 /*
2865 * shutdown(2), if we have it, will cause it to unblock if it's stuck
2866 * waiting for the destination.
2867 */
2868 qemu_file_shutdown(ms->rp_state.from_dst_file);
2869 mark_source_rp_bad(ms);
2870 }
2871 trace_await_return_path_close_on_source_joining();
2872 qemu_thread_join(&ms->rp_state.rp_thread);
2873 trace_await_return_path_close_on_source_close();
2874 return ms->rp_state.error;
2875}
2876
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002877/*
2878 * Switch from normal iteration to postcopy
2879 * Returns non-0 on error
2880 */
Peter Xu7287cbd2018-01-03 20:20:09 +08002881static int postcopy_start(MigrationState *ms)
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002882{
2883 int ret;
Daniel P. Berrange61b67d42016-04-27 11:05:01 +01002884 QIOChannelBuffer *bioc;
2885 QEMUFile *fb;
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002886 int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01002887 int64_t bandwidth = migrate_max_postcopy_bandwidth();
Dr. David Alan Gilbertef8d6482017-02-02 15:59:09 +00002888 bool restart_block = false;
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +01002889 int cur_state = MIGRATION_STATUS_ACTIVE;
2890 if (!migrate_pause_before_switchover()) {
2891 migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,
2892 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2893 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002894
2895 trace_postcopy_start();
2896 qemu_mutex_lock_iothread();
2897 trace_postcopy_start_set_run();
2898
Daniel Henrique Barbozafb064112018-12-05 17:47:01 -02002899 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002900 global_state_store();
2901 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01002902 if (ret < 0) {
2903 goto fail;
2904 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002905
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +01002906 ret = migration_maybe_pause(ms, &cur_state,
2907 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2908 if (ret < 0) {
2909 goto fail;
2910 }
2911
Kevin Wolf76b1c7f2015-12-22 14:07:08 +01002912 ret = bdrv_inactivate_all();
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002913 if (ret < 0) {
2914 goto fail;
2915 }
Dr. David Alan Gilbertef8d6482017-02-02 15:59:09 +00002916 restart_block = true;
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002917
2918 /*
Dr. David Alan Gilbert1c0d2492015-11-11 14:02:27 +00002919 * Cause any non-postcopiable, but iterative devices to
2920 * send out their final data.
2921 */
Fam Zhenga1fbe752017-06-17 00:06:58 +08002922 qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false);
Dr. David Alan Gilbert1c0d2492015-11-11 14:02:27 +00002923
2924 /*
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002925 * in Finish migrate and with the io-lock held everything should
2926 * be quiet, but we've potentially still got dirty pages and we
2927 * need to tell the destination to throw any pages it's already received
2928 * that are dirty
2929 */
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03002930 if (migrate_postcopy_ram()) {
2931 if (ram_postcopy_send_discard_bitmap(ms)) {
2932 error_report("postcopy send discard bitmap failed");
2933 goto fail;
2934 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002935 }
2936
2937 /*
2938 * send rest of state - note things that are doing postcopy
2939 * will notice we're in POSTCOPY_ACTIVE and not actually
2940 * wrap their state up here
2941 */
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01002942 /* 0 max-postcopy-bandwidth means unlimited */
2943 if (!bandwidth) {
2944 qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
2945 } else {
2946 qemu_file_set_rate_limit(ms->to_dst_file, bandwidth / XFER_LIMIT_RATIO);
2947 }
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03002948 if (migrate_postcopy_ram()) {
2949 /* Ping just for debugging, helps line traces up */
2950 qemu_savevm_send_ping(ms->to_dst_file, 2);
2951 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002952
2953 /*
2954 * While loading the device state we may trigger page transfer
2955 * requests and the fd must be free to process those, and thus
2956 * the destination must read the whole device state off the fd before
2957 * it starts processing it. Unfortunately the ad-hoc migration format
2958 * doesn't allow the destination to know the size to read without fully
2959 * parsing it through each devices load-state code (especially the open
2960 * coded devices that use get/put).
2961 * So we wrap the device state up in a package with a length at the start;
2962 * to do this we use a qemu_buf to hold the whole of the device state.
2963 */
Daniel P. Berrange61b67d42016-04-27 11:05:01 +01002964 bioc = qio_channel_buffer_new(4096);
Daniel P. Berrange6f01f132016-09-30 11:57:14 +01002965 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer");
Daniel P. Berrange61b67d42016-04-27 11:05:01 +01002966 fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc));
2967 object_unref(OBJECT(bioc));
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002968
Dr. David Alan Gilbertc76201a2015-11-05 18:11:18 +00002969 /*
2970 * Make sure the receiver can get incoming pages before we send the rest
2971 * of the state
2972 */
2973 qemu_savevm_send_postcopy_listen(fb);
2974
Fam Zhenga1fbe752017-06-17 00:06:58 +08002975 qemu_savevm_state_complete_precopy(fb, false, false);
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03002976 if (migrate_postcopy_ram()) {
2977 qemu_savevm_send_ping(fb, 3);
2978 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002979
2980 qemu_savevm_send_postcopy_run(fb);
2981
2982 /* <><> end of stuff going into the package */
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002983
Dr. David Alan Gilbertef8d6482017-02-02 15:59:09 +00002984 /* Last point of recovery; as soon as we send the package the destination
2985 * can open devices and potentially start running.
2986 * Lets just check again we've not got any errors.
2987 */
2988 ret = qemu_file_get_error(ms->to_dst_file);
2989 if (ret) {
2990 error_report("postcopy_start: Migration stream errored (pre package)");
2991 goto fail_closefb;
2992 }
2993
2994 restart_block = false;
2995
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002996 /* Now send that blob */
Daniel P. Berrange61b67d42016-04-27 11:05:01 +01002997 if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) {
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00002998 goto fail_closefb;
2999 }
3000 qemu_fclose(fb);
Dr. David Alan Gilbertb82fc322016-02-22 17:17:32 +00003001
3002 /* Send a notify to give a chance for anything that needs to happen
3003 * at the transition to postcopy and after the device state; in particular
3004 * spice needs to trigger a transition now
3005 */
3006 ms->postcopy_after_devices = true;
3007 notifier_list_notify(&migration_state_notifiers, ms);
3008
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003009 ms->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop;
3010
3011 qemu_mutex_unlock_iothread();
3012
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03003013 if (migrate_postcopy_ram()) {
3014 /*
3015 * Although this ping is just for debug, it could potentially be
3016 * used for getting a better measurement of downtime at the source.
3017 */
3018 qemu_savevm_send_ping(ms->to_dst_file, 4);
3019 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003020
Pavel Butsykinced1c612017-02-03 18:23:21 +03003021 if (migrate_release_ram()) {
3022 ram_postcopy_migrated_memory_release(ms);
3023 }
3024
zhanghailiang89a02a92016-01-15 11:37:42 +08003025 ret = qemu_file_get_error(ms->to_dst_file);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003026 if (ret) {
3027 error_report("postcopy_start: Migration stream errored");
zhanghailiang48781e52015-12-16 11:47:33 +00003028 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003029 MIGRATION_STATUS_FAILED);
3030 }
3031
3032 return ret;
3033
3034fail_closefb:
3035 qemu_fclose(fb);
3036fail:
zhanghailiang48781e52015-12-16 11:47:33 +00003037 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003038 MIGRATION_STATUS_FAILED);
Dr. David Alan Gilbertef8d6482017-02-02 15:59:09 +00003039 if (restart_block) {
3040 /* A failure happened early enough that we know the destination hasn't
3041 * accessed block devices, so we're safe to recover.
3042 */
3043 Error *local_err = NULL;
3044
3045 bdrv_invalidate_cache_all(&local_err);
3046 if (local_err) {
3047 error_report_err(local_err);
3048 }
3049 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003050 qemu_mutex_unlock_iothread();
3051 return -1;
3052}
3053
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003054/**
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01003055 * migration_maybe_pause: Pause if required to by
3056 * migrate_pause_before_switchover called with the iothread locked
3057 * Returns: 0 on success
3058 */
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +01003059static int migration_maybe_pause(MigrationState *s,
3060 int *current_active_state,
3061 int new_state)
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01003062{
3063 if (!migrate_pause_before_switchover()) {
3064 return 0;
3065 }
3066
3067 /* Since leaving this state is not atomic with posting the semaphore
3068 * it's possible that someone could have issued multiple migrate_continue
3069 * and the semaphore is incorrectly positive at this point;
3070 * the docs say it's undefined to reinit a semaphore that's already
3071 * init'd, so use timedwait to eat up any existing posts.
3072 */
3073 while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) {
3074 /* This block intentionally left blank */
3075 }
3076
Zhimin Feng89583382020-01-14 17:43:09 +08003077 /*
3078 * If the migration is cancelled when it is in the completion phase,
3079 * the migration state is set to MIGRATION_STATUS_CANCELLING.
3080 * So we don't need to wait a semaphore, otherwise we would always
3081 * wait for the 'pause_sem' semaphore.
3082 */
3083 if (s->state != MIGRATION_STATUS_CANCELLING) {
3084 qemu_mutex_unlock_iothread();
3085 migrate_set_state(&s->state, *current_active_state,
3086 MIGRATION_STATUS_PRE_SWITCHOVER);
3087 qemu_sem_wait(&s->pause_sem);
3088 migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
3089 new_state);
3090 *current_active_state = new_state;
3091 qemu_mutex_lock_iothread();
3092 }
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01003093
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +01003094 return s->state == new_state ? 0 : -EINVAL;
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01003095}
3096
3097/**
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003098 * migration_completion: Used by migration_thread when there's not much left.
3099 * The caller 'breaks' the loop when this returns.
3100 *
3101 * @s: Current migration state
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003102 */
Peter Xu2ad87302018-01-03 20:20:14 +08003103static void migration_completion(MigrationState *s)
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003104{
3105 int ret;
Peter Xu2ad87302018-01-03 20:20:14 +08003106 int current_active_state = s->state;
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003107
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003108 if (s->state == MIGRATION_STATUS_ACTIVE) {
3109 qemu_mutex_lock_iothread();
Peter Xu64909f92018-01-03 20:20:10 +08003110 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Daniel Henrique Barbozafb064112018-12-05 17:47:01 -02003111 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
Peter Xu7287cbd2018-01-03 20:20:09 +08003112 s->vm_was_running = runstate_is_running();
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003113 ret = global_state_store();
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003114
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003115 if (!ret) {
Fam Zhenga1fbe752017-06-17 00:06:58 +08003116 bool inactivate = !migrate_colo_enabled();
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003117 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
Daniel P. Berrangé626ff652021-04-15 14:33:51 +01003118 trace_migration_completion_vm_stop(ret);
Kevin Wolff07fa4c2017-05-22 17:10:38 +02003119 if (ret >= 0) {
Dr. David Alan Gilbert0331c8c2017-10-20 10:05:56 +01003120 ret = migration_maybe_pause(s, &current_active_state,
3121 MIGRATION_STATUS_DEVICE);
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01003122 }
3123 if (ret >= 0) {
Kevin Wolff07fa4c2017-05-22 17:10:38 +02003124 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
Fam Zhenga1fbe752017-06-17 00:06:58 +08003125 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
3126 inactivate);
Kevin Wolff07fa4c2017-05-22 17:10:38 +02003127 }
Fam Zhenga1fbe752017-06-17 00:06:58 +08003128 if (inactivate && ret >= 0) {
3129 s->block_inactive = true;
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003130 }
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003131 }
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003132 qemu_mutex_unlock_iothread();
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003133
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003134 if (ret < 0) {
3135 goto fail;
3136 }
3137 } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
3138 trace_migration_completion_postcopy_end();
3139
zhanghailiang89a02a92016-01-15 11:37:42 +08003140 qemu_savevm_state_complete_postcopy(s->to_dst_file);
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003141 trace_migration_completion_postcopy_end_after_complete();
Longpeng(Mike)6ba11212020-11-05 17:17:26 +08003142 } else if (s->state == MIGRATION_STATUS_CANCELLING) {
3143 goto fail;
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003144 }
3145
3146 /*
3147 * If rp was opened we must clean up the thread before
3148 * cleaning everything else up (since if there are no failures
3149 * it will wait for the destination to send it's status in
3150 * a SHUT command).
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003151 */
Peter Xu0425dc92017-05-31 18:35:34 +08003152 if (s->rp_state.from_dst_file) {
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003153 int rp_error;
Peter Xu0425dc92017-05-31 18:35:34 +08003154 trace_migration_return_path_end_before();
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003155 rp_error = await_return_path_close_on_source(s);
Peter Xu0425dc92017-05-31 18:35:34 +08003156 trace_migration_return_path_end_after(rp_error);
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003157 if (rp_error) {
Greg Kurzfe904ea2016-05-18 15:44:36 +02003158 goto fail_invalidate;
Dr. David Alan Gilbertb10ac0c2015-11-05 18:11:06 +00003159 }
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003160 }
3161
zhanghailiang89a02a92016-01-15 11:37:42 +08003162 if (qemu_file_get_error(s->to_dst_file)) {
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003163 trace_migration_completion_file_err();
Greg Kurzfe904ea2016-05-18 15:44:36 +02003164 goto fail_invalidate;
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003165 }
3166
zhanghailiang0b827d52016-10-27 14:42:54 +08003167 if (!migrate_colo_enabled()) {
3168 migrate_set_state(&s->state, current_active_state,
3169 MIGRATION_STATUS_COMPLETED);
3170 }
3171
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003172 return;
3173
Greg Kurzfe904ea2016-05-18 15:44:36 +02003174fail_invalidate:
3175 /* If not doing postcopy, vm_start() will be called: let's regain
3176 * control on images.
3177 */
Dr. David Alan Gilbert6039dd52018-02-05 09:13:37 +00003178 if (s->state == MIGRATION_STATUS_ACTIVE ||
3179 s->state == MIGRATION_STATUS_DEVICE) {
Greg Kurzfe904ea2016-05-18 15:44:36 +02003180 Error *local_err = NULL;
3181
zhanghailiang1d2acc32017-01-24 15:59:52 +08003182 qemu_mutex_lock_iothread();
Greg Kurzfe904ea2016-05-18 15:44:36 +02003183 bdrv_invalidate_cache_all(&local_err);
3184 if (local_err) {
3185 error_report_err(local_err);
zhanghailiang1d2acc32017-01-24 15:59:52 +08003186 } else {
3187 s->block_inactive = false;
Greg Kurzfe904ea2016-05-18 15:44:36 +02003188 }
zhanghailiang1d2acc32017-01-24 15:59:52 +08003189 qemu_mutex_unlock_iothread();
Greg Kurzfe904ea2016-05-18 15:44:36 +02003190 }
3191
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003192fail:
zhanghailiang48781e52015-12-16 11:47:33 +00003193 migrate_set_state(&s->state, current_active_state,
3194 MIGRATION_STATUS_FAILED);
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003195}
3196
Andrey Gruzdev85182782021-01-29 13:14:06 +03003197/**
3198 * bg_migration_completion: Used by bg_migration_thread when after all the
3199 * RAM has been saved. The caller 'breaks' the loop when this returns.
3200 *
3201 * @s: Current migration state
3202 */
3203static void bg_migration_completion(MigrationState *s)
3204{
3205 int current_active_state = s->state;
3206
3207 /*
3208 * Stop tracking RAM writes - un-protect memory, un-register UFFD
3209 * memory ranges, flush kernel wait queues and wake up threads
3210 * waiting for write fault to be resolved.
3211 */
3212 ram_write_tracking_stop();
3213
3214 if (s->state == MIGRATION_STATUS_ACTIVE) {
3215 /*
3216 * By this moment we have RAM content saved into the migration stream.
3217 * The next step is to flush the non-RAM content (device state)
3218 * right after the ram content. The device state has been stored into
3219 * the temporary buffer before RAM saving started.
3220 */
3221 qemu_put_buffer(s->to_dst_file, s->bioc->data, s->bioc->usage);
3222 qemu_fflush(s->to_dst_file);
3223 } else if (s->state == MIGRATION_STATUS_CANCELLING) {
3224 goto fail;
3225 }
3226
3227 if (qemu_file_get_error(s->to_dst_file)) {
3228 trace_migration_completion_file_err();
3229 goto fail;
3230 }
3231
3232 migrate_set_state(&s->state, current_active_state,
3233 MIGRATION_STATUS_COMPLETED);
3234 return;
3235
3236fail:
3237 migrate_set_state(&s->state, current_active_state,
3238 MIGRATION_STATUS_FAILED);
3239}
3240
zhanghailiang35a6ed42016-10-27 14:42:52 +08003241bool migrate_colo_enabled(void)
3242{
3243 MigrationState *s = migrate_get_current();
3244 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO];
3245}
3246
Peter Xub23c2ad2018-05-02 18:47:19 +08003247typedef enum MigThrError {
3248 /* No error detected */
3249 MIG_THR_ERR_NONE = 0,
3250 /* Detected error, but resumed successfully */
3251 MIG_THR_ERR_RECOVERED = 1,
3252 /* Detected fatal error, need to exit */
3253 MIG_THR_ERR_FATAL = 2,
3254} MigThrError;
3255
Peter Xu94190692018-05-02 18:47:34 +08003256static int postcopy_resume_handshake(MigrationState *s)
3257{
3258 qemu_savevm_send_postcopy_resume(s->to_dst_file);
3259
3260 while (s->state == MIGRATION_STATUS_POSTCOPY_RECOVER) {
3261 qemu_sem_wait(&s->rp_state.rp_sem);
3262 }
3263
3264 if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
3265 return 0;
3266 }
3267
3268 return -1;
3269}
3270
Peter Xu135b87b2018-05-02 18:47:25 +08003271/* Return zero if success, or <0 for error */
3272static int postcopy_do_resume(MigrationState *s)
3273{
Peter Xud1b8ead2018-05-02 18:47:31 +08003274 int ret;
3275
3276 /*
3277 * Call all the resume_prepare() hooks, so that modules can be
3278 * ready for the migration resume.
3279 */
3280 ret = qemu_savevm_state_resume_prepare(s);
3281 if (ret) {
3282 error_report("%s: resume_prepare() failure detected: %d",
3283 __func__, ret);
3284 return ret;
3285 }
3286
3287 /*
Peter Xu94190692018-05-02 18:47:34 +08003288 * Last handshake with destination on the resume (destination will
3289 * switch to postcopy-active afterwards)
Peter Xud1b8ead2018-05-02 18:47:31 +08003290 */
Peter Xu94190692018-05-02 18:47:34 +08003291 ret = postcopy_resume_handshake(s);
3292 if (ret) {
3293 error_report("%s: handshake failed: %d", __func__, ret);
3294 return ret;
3295 }
Peter Xud1b8ead2018-05-02 18:47:31 +08003296
Peter Xu135b87b2018-05-02 18:47:25 +08003297 return 0;
3298}
3299
Peter Xub23c2ad2018-05-02 18:47:19 +08003300/*
3301 * We don't return until we are in a safe state to continue current
3302 * postcopy migration. Returns MIG_THR_ERR_RECOVERED if recovered, or
3303 * MIG_THR_ERR_FATAL if unrecovery failure happened.
3304 */
3305static MigThrError postcopy_pause(MigrationState *s)
3306{
3307 assert(s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
Peter Xub23c2ad2018-05-02 18:47:19 +08003308
Peter Xu135b87b2018-05-02 18:47:25 +08003309 while (true) {
Peter Xu62df0662018-05-02 18:47:38 +08003310 QEMUFile *file;
3311
Peter Xu135b87b2018-05-02 18:47:25 +08003312 /* Current channel is possibly broken. Release it. */
3313 assert(s->to_dst_file);
Peter Xu62df0662018-05-02 18:47:38 +08003314 qemu_mutex_lock(&s->qemu_file_lock);
3315 file = s->to_dst_file;
Peter Xu135b87b2018-05-02 18:47:25 +08003316 s->to_dst_file = NULL;
Peter Xu62df0662018-05-02 18:47:38 +08003317 qemu_mutex_unlock(&s->qemu_file_lock);
3318
3319 qemu_file_shutdown(file);
3320 qemu_fclose(file);
Peter Xub23c2ad2018-05-02 18:47:19 +08003321
Peter Xud246ea52020-10-21 17:27:20 -04003322 migrate_set_state(&s->state, s->state,
3323 MIGRATION_STATUS_POSTCOPY_PAUSED);
3324
Peter Xu135b87b2018-05-02 18:47:25 +08003325 error_report("Detected IO failure for postcopy. "
3326 "Migration paused.");
3327
3328 /*
3329 * We wait until things fixed up. Then someone will setup the
3330 * status back for us.
3331 */
3332 while (s->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
3333 qemu_sem_wait(&s->postcopy_pause_sem);
3334 }
3335
3336 if (s->state == MIGRATION_STATUS_POSTCOPY_RECOVER) {
3337 /* Woken up by a recover procedure. Give it a shot */
3338
3339 /*
3340 * Firstly, let's wake up the return path now, with a new
3341 * return path channel.
3342 */
3343 qemu_sem_post(&s->postcopy_pause_rp_sem);
3344
3345 /* Do the resume logic */
3346 if (postcopy_do_resume(s) == 0) {
3347 /* Let's continue! */
3348 trace_postcopy_pause_continued();
3349 return MIG_THR_ERR_RECOVERED;
3350 } else {
3351 /*
3352 * Something wrong happened during the recovery, let's
3353 * pause again. Pause is always better than throwing
3354 * data away.
3355 */
3356 continue;
3357 }
3358 } else {
3359 /* This is not right... Time to quit. */
3360 return MIG_THR_ERR_FATAL;
3361 }
Peter Xub23c2ad2018-05-02 18:47:19 +08003362 }
Peter Xub23c2ad2018-05-02 18:47:19 +08003363}
3364
3365static MigThrError migration_detect_error(MigrationState *s)
3366{
3367 int ret;
Dr. David Alan Gilbertc3c5eae2019-02-19 19:59:28 +00003368 int state = s->state;
Yury Kotov3d661c82019-04-22 13:34:20 +03003369 Error *local_error = NULL;
Dr. David Alan Gilbertc3c5eae2019-02-19 19:59:28 +00003370
3371 if (state == MIGRATION_STATUS_CANCELLING ||
3372 state == MIGRATION_STATUS_CANCELLED) {
3373 /* End the migration, but don't set the state to failed */
3374 return MIG_THR_ERR_FATAL;
3375 }
Peter Xub23c2ad2018-05-02 18:47:19 +08003376
3377 /* Try to detect any file errors */
Yury Kotov3d661c82019-04-22 13:34:20 +03003378 ret = qemu_file_get_error_obj(s->to_dst_file, &local_error);
Peter Xub23c2ad2018-05-02 18:47:19 +08003379 if (!ret) {
3380 /* Everything is fine */
Yury Kotov3d661c82019-04-22 13:34:20 +03003381 assert(!local_error);
Peter Xub23c2ad2018-05-02 18:47:19 +08003382 return MIG_THR_ERR_NONE;
3383 }
3384
Yury Kotov3d661c82019-04-22 13:34:20 +03003385 if (local_error) {
3386 migrate_set_error(s, local_error);
3387 error_free(local_error);
3388 }
3389
Dr. David Alan Gilbertc3c5eae2019-02-19 19:59:28 +00003390 if (state == MIGRATION_STATUS_POSTCOPY_ACTIVE && ret == -EIO) {
Peter Xub23c2ad2018-05-02 18:47:19 +08003391 /*
3392 * For postcopy, we allow the network to be down for a
3393 * while. After that, it can be continued by a
3394 * recovery phase.
3395 */
3396 return postcopy_pause(s);
3397 } else {
3398 /*
3399 * For precopy (or postcopy with error outside IO), we fail
3400 * with no time.
3401 */
Dr. David Alan Gilbertc3c5eae2019-02-19 19:59:28 +00003402 migrate_set_state(&s->state, state, MIGRATION_STATUS_FAILED);
Peter Xub23c2ad2018-05-02 18:47:19 +08003403 trace_migration_thread_file_err();
3404
3405 /* Time to stop the migration, now. */
3406 return MIG_THR_ERR_FATAL;
3407 }
3408}
3409
Wei Yang268dcd42019-09-12 10:49:57 +08003410/* How many bytes have we transferred since the beginning of the migration */
Juan Quintela0c8f0ef2018-06-26 15:38:00 +02003411static uint64_t migration_total_bytes(MigrationState *s)
3412{
Juan Quintelab9ee2f72016-01-15 11:40:13 +01003413 return qemu_ftell(s->to_dst_file) + ram_counters.multifd_bytes;
Juan Quintela0c8f0ef2018-06-26 15:38:00 +02003414}
3415
Peter Xucf011f02018-01-03 20:20:11 +08003416static void migration_calculate_complete(MigrationState *s)
3417{
Juan Quintela0c8f0ef2018-06-26 15:38:00 +02003418 uint64_t bytes = migration_total_bytes(s);
Peter Xucf011f02018-01-03 20:20:11 +08003419 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintela6cde6fb2018-06-26 15:26:35 +02003420 int64_t transfer_time;
Peter Xucf011f02018-01-03 20:20:11 +08003421
3422 s->total_time = end_time - s->start_time;
3423 if (!s->downtime) {
3424 /*
3425 * It's still not set, so we are precopy migration. For
3426 * postcopy, downtime is calculated during postcopy_start().
3427 */
3428 s->downtime = end_time - s->downtime_start;
3429 }
3430
Juan Quintela6cde6fb2018-06-26 15:26:35 +02003431 transfer_time = s->total_time - s->setup_time;
3432 if (transfer_time) {
3433 s->mbps = ((double) bytes * 8.0) / transfer_time / 1000;
Peter Xucf011f02018-01-03 20:20:11 +08003434 }
3435}
3436
Ivan Ren87f3bd82019-08-02 18:18:41 +08003437static void update_iteration_initial_status(MigrationState *s)
3438{
3439 /*
3440 * Update these three fields at the same time to avoid mismatch info lead
3441 * wrong speed calculation.
3442 */
3443 s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3444 s->iteration_initial_bytes = migration_total_bytes(s);
3445 s->iteration_initial_pages = ram_get_total_transferred_pages();
3446}
3447
Peter Xub15df1a2018-01-03 20:20:13 +08003448static void migration_update_counters(MigrationState *s,
3449 int64_t current_time)
3450{
Xiao Guangrongaecbfe92019-01-11 14:37:30 +08003451 uint64_t transferred, transferred_pages, time_spent;
Juan Quintela0c8f0ef2018-06-26 15:38:00 +02003452 uint64_t current_bytes; /* bytes transferred since the beginning */
Peter Xub15df1a2018-01-03 20:20:13 +08003453 double bandwidth;
3454
3455 if (current_time < s->iteration_start_time + BUFFER_DELAY) {
3456 return;
3457 }
3458
Juan Quintela0c8f0ef2018-06-26 15:38:00 +02003459 current_bytes = migration_total_bytes(s);
3460 transferred = current_bytes - s->iteration_initial_bytes;
Peter Xub15df1a2018-01-03 20:20:13 +08003461 time_spent = current_time - s->iteration_start_time;
3462 bandwidth = (double)transferred / time_spent;
Wei Wang0781c1e2018-01-22 19:36:39 +08003463 s->threshold_size = bandwidth * s->parameters.downtime_limit;
Peter Xub15df1a2018-01-03 20:20:13 +08003464
3465 s->mbps = (((double) transferred * 8.0) /
3466 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0;
3467
Xiao Guangrongaecbfe92019-01-11 14:37:30 +08003468 transferred_pages = ram_get_total_transferred_pages() -
3469 s->iteration_initial_pages;
3470 s->pages_per_second = (double) transferred_pages /
3471 (((double) time_spent / 1000.0));
3472
Peter Xub15df1a2018-01-03 20:20:13 +08003473 /*
3474 * if we haven't sent anything, we don't want to
3475 * recalculate. 10000 is a small enough number for our purposes
3476 */
3477 if (ram_counters.dirty_pages_rate && transferred > 10000) {
Balamuruhan S650af892018-06-12 14:20:09 +05303478 s->expected_downtime = ram_counters.remaining / bandwidth;
Peter Xub15df1a2018-01-03 20:20:13 +08003479 }
3480
3481 qemu_file_reset_rate_limit(s->to_dst_file);
3482
Ivan Ren87f3bd82019-08-02 18:18:41 +08003483 update_iteration_initial_status(s);
Peter Xub15df1a2018-01-03 20:20:13 +08003484
3485 trace_migrate_transferred(transferred, time_spent,
Wei Wang0781c1e2018-01-22 19:36:39 +08003486 bandwidth, s->threshold_size);
Peter Xub15df1a2018-01-03 20:20:13 +08003487}
3488
Peter Xu2ad87302018-01-03 20:20:14 +08003489/* Migration thread iteration status */
3490typedef enum {
3491 MIG_ITERATE_RESUME, /* Resume current iteration */
3492 MIG_ITERATE_SKIP, /* Skip current iteration */
3493 MIG_ITERATE_BREAK, /* Break the loop */
3494} MigIterateState;
3495
3496/*
3497 * Return true if continue to the next iteration directly, false
3498 * otherwise.
3499 */
3500static MigIterateState migration_iteration_run(MigrationState *s)
3501{
Vladimir Sementsov-Ogievskiy47995022018-03-13 15:34:00 -04003502 uint64_t pending_size, pend_pre, pend_compat, pend_post;
Peter Xu2ad87302018-01-03 20:20:14 +08003503 bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;
3504
Vladimir Sementsov-Ogievskiy47995022018-03-13 15:34:00 -04003505 qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, &pend_pre,
3506 &pend_compat, &pend_post);
3507 pending_size = pend_pre + pend_compat + pend_post;
Peter Xu2ad87302018-01-03 20:20:14 +08003508
3509 trace_migrate_pending(pending_size, s->threshold_size,
Vladimir Sementsov-Ogievskiy47995022018-03-13 15:34:00 -04003510 pend_pre, pend_compat, pend_post);
Peter Xu2ad87302018-01-03 20:20:14 +08003511
3512 if (pending_size && pending_size >= s->threshold_size) {
3513 /* Still a significant amount to transfer */
Wei Yang52aec702019-07-18 16:37:47 +08003514 if (!in_postcopy && pend_pre <= s->threshold_size &&
Stefan Hajnoczid73415a2020-09-23 11:56:46 +01003515 qatomic_read(&s->start_postcopy)) {
Peter Xu2ad87302018-01-03 20:20:14 +08003516 if (postcopy_start(s)) {
3517 error_report("%s: postcopy failed to start", __func__);
3518 }
3519 return MIG_ITERATE_SKIP;
3520 }
3521 /* Just another iteration step */
Wei Yang17d93512019-10-06 06:05:16 +08003522 qemu_savevm_state_iterate(s->to_dst_file, in_postcopy);
Peter Xu2ad87302018-01-03 20:20:14 +08003523 } else {
3524 trace_migration_thread_low_pending(pending_size);
3525 migration_completion(s);
3526 return MIG_ITERATE_BREAK;
3527 }
3528
3529 return MIG_ITERATE_RESUME;
3530}
3531
Peter Xu199aa6d2018-01-03 20:20:15 +08003532static void migration_iteration_finish(MigrationState *s)
3533{
3534 /* If we enabled cpu throttling for auto-converge, turn it off. */
3535 cpu_throttle_stop();
3536
3537 qemu_mutex_lock_iothread();
3538 switch (s->state) {
3539 case MIGRATION_STATUS_COMPLETED:
3540 migration_calculate_complete(s);
3541 runstate_set(RUN_STATE_POSTMIGRATE);
3542 break;
3543
3544 case MIGRATION_STATUS_ACTIVE:
3545 /*
3546 * We should really assert here, but since it's during
3547 * migration, let's try to reduce the usage of assertions.
3548 */
3549 if (!migrate_colo_enabled()) {
3550 error_report("%s: critical error: calling COLO code without "
3551 "COLO enabled", __func__);
3552 }
3553 migrate_start_colo_process(s);
3554 /*
3555 * Fixme: we will run VM in COLO no matter its old running state.
3556 * After exited COLO, we will keep running.
3557 */
3558 s->vm_was_running = true;
3559 /* Fallthrough */
3560 case MIGRATION_STATUS_FAILED:
3561 case MIGRATION_STATUS_CANCELLED:
Dr. David Alan Gilbert57225e52018-07-19 10:22:57 +01003562 case MIGRATION_STATUS_CANCELLING:
Peter Xu199aa6d2018-01-03 20:20:15 +08003563 if (s->vm_was_running) {
3564 vm_start();
3565 } else {
3566 if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
3567 runstate_set(RUN_STATE_POSTMIGRATE);
3568 }
3569 }
3570 break;
3571
3572 default:
3573 /* Should not reach here, but if so, forgive the VM. */
3574 error_report("%s: Unknown ending state %d", __func__, s->state);
3575 break;
3576 }
Yury Kotovfd392cf2019-04-08 14:33:43 +03003577 migrate_fd_cleanup_schedule(s);
Peter Xu199aa6d2018-01-03 20:20:15 +08003578 qemu_mutex_unlock_iothread();
3579}
3580
Andrey Gruzdev85182782021-01-29 13:14:06 +03003581static void bg_migration_iteration_finish(MigrationState *s)
3582{
3583 qemu_mutex_lock_iothread();
3584 switch (s->state) {
3585 case MIGRATION_STATUS_COMPLETED:
3586 migration_calculate_complete(s);
3587 break;
3588
3589 case MIGRATION_STATUS_ACTIVE:
3590 case MIGRATION_STATUS_FAILED:
3591 case MIGRATION_STATUS_CANCELLED:
3592 case MIGRATION_STATUS_CANCELLING:
3593 break;
3594
3595 default:
3596 /* Should not reach here, but if so, forgive the VM. */
3597 error_report("%s: Unknown ending state %d", __func__, s->state);
3598 break;
3599 }
3600
3601 migrate_fd_cleanup_schedule(s);
3602 qemu_mutex_unlock_iothread();
3603}
3604
3605/*
3606 * Return true if continue to the next iteration directly, false
3607 * otherwise.
3608 */
3609static MigIterateState bg_migration_iteration_run(MigrationState *s)
3610{
3611 int res;
3612
3613 res = qemu_savevm_state_iterate(s->to_dst_file, false);
3614 if (res > 0) {
3615 bg_migration_completion(s);
3616 return MIG_ITERATE_BREAK;
3617 }
3618
3619 return MIG_ITERATE_RESUME;
3620}
3621
Dr. David Alan Gilbertad767be2018-06-13 11:26:41 +01003622void migration_make_urgent_request(void)
3623{
3624 qemu_sem_post(&migrate_get_current()->rate_limit_sem);
3625}
3626
3627void migration_consume_urgent_request(void)
3628{
3629 qemu_sem_wait(&migrate_get_current()->rate_limit_sem);
3630}
3631
Dr. David Alan Gilbert97e1e062019-12-05 10:29:18 +00003632/* Returns true if the rate limiting was broken by an urgent request */
3633bool migration_rate_limit(void)
3634{
3635 int64_t now = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3636 MigrationState *s = migrate_get_current();
3637
3638 bool urgent = false;
3639 migration_update_counters(s, now);
3640 if (qemu_file_rate_limit(s->to_dst_file)) {
Lukas Straub77386122020-05-20 22:42:32 +02003641
3642 if (qemu_file_get_error(s->to_dst_file)) {
3643 return false;
3644 }
Dr. David Alan Gilbert97e1e062019-12-05 10:29:18 +00003645 /*
3646 * Wait for a delay to do rate limiting OR
3647 * something urgent to post the semaphore.
3648 */
3649 int ms = s->iteration_start_time + BUFFER_DELAY - now;
3650 trace_migration_rate_limit_pre(ms);
3651 if (qemu_sem_timedwait(&s->rate_limit_sem, ms) == 0) {
3652 /*
3653 * We were woken by one or more urgent things but
3654 * the timedwait will have consumed one of them.
3655 * The service routine for the urgent wake will dec
3656 * the semaphore itself for each item it consumes,
3657 * so add this one we just eat back.
3658 */
3659 qemu_sem_post(&s->rate_limit_sem);
3660 urgent = true;
3661 }
3662 trace_migration_rate_limit_post(urgent);
3663 }
3664 return urgent;
3665}
3666
Dr. David Alan Gilbert70b20472015-11-05 18:10:49 +00003667/*
3668 * Master migration thread on the source VM.
3669 * It drives the migration and pumps the data down the outgoing channel.
3670 */
Juan Quintela5f496a12013-02-22 17:36:30 +01003671static void *migration_thread(void *opaque)
Juan Quintela0d82d0e2012-10-03 14:18:33 +02003672{
Juan Quintela9848a402012-12-19 09:55:50 +01003673 MigrationState *s = opaque;
Alex Blighbc72ad62013-08-21 16:03:08 +01003674 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
Peter Xub23c2ad2018-05-02 18:47:19 +08003675 MigThrError thr_error;
Dr. David Alan Gilbertad767be2018-06-13 11:26:41 +01003676 bool urgent = false;
Juan Quintela76f59332012-10-03 20:16:24 +02003677
Paolo Bonziniab28bd22015-07-09 08:55:38 +02003678 rcu_register_thread();
3679
Dr. David Alan Gilbert892ae712019-02-27 16:49:00 +00003680 object_ref(OBJECT(s));
Ivan Ren87f3bd82019-08-02 18:18:41 +08003681 update_iteration_initial_status(s);
Peter Xub15df1a2018-01-03 20:20:13 +08003682
zhanghailiang89a02a92016-01-15 11:37:42 +08003683 qemu_savevm_state_header(s->to_dst_file);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003684
Peter Xu62a02652017-06-14 15:55:58 +08003685 /*
3686 * If we opened the return path, we need to make sure dst has it
3687 * opened as well.
3688 */
3689 if (s->rp_state.from_dst_file) {
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003690 /* Now tell the dest that it should open its end so it can reply */
zhanghailiang89a02a92016-01-15 11:37:42 +08003691 qemu_savevm_send_open_return_path(s->to_dst_file);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003692
3693 /* And do a ping that will make stuff easier to debug */
zhanghailiang89a02a92016-01-15 11:37:42 +08003694 qemu_savevm_send_ping(s->to_dst_file, 1);
Peter Xu0425dc92017-05-31 18:35:34 +08003695 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003696
Vladimir Sementsov-Ogievskiy58110f02017-07-10 19:30:16 +03003697 if (migrate_postcopy()) {
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003698 /*
3699 * Tell the destination that we *might* want to do postcopy later;
3700 * if the other end can't do postcopy it should fail now, nice and
3701 * early.
3702 */
zhanghailiang89a02a92016-01-15 11:37:42 +08003703 qemu_savevm_send_postcopy_advise(s->to_dst_file);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003704 }
3705
Zhang Chenaad555c2018-09-03 12:38:47 +08003706 if (migrate_colo_enabled()) {
3707 /* Notify migration destination that we enable COLO */
3708 qemu_savevm_send_colo_enable(s->to_dst_file);
3709 }
3710
Juan Quintela9907e842017-06-28 11:52:24 +02003711 qemu_savevm_state_setup(s->to_dst_file);
Juan Quintela0d82d0e2012-10-03 14:18:33 +02003712
Keqian Zhud05de9e2020-02-04 13:08:41 +08003713 if (qemu_savevm_state_guest_unplug_pending()) {
Jens Freimannc7e0acd2019-10-29 12:49:02 +01003714 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3715 MIGRATION_STATUS_WAIT_UNPLUG);
3716
3717 while (s->state == MIGRATION_STATUS_WAIT_UNPLUG &&
3718 qemu_savevm_state_guest_unplug_pending()) {
3719 qemu_sem_timedwait(&s->wait_unplug_sem, 250);
3720 }
3721
3722 migrate_set_state(&s->state, MIGRATION_STATUS_WAIT_UNPLUG,
3723 MIGRATION_STATUS_ACTIVE);
3724 }
3725
Alex Blighbc72ad62013-08-21 16:03:08 +01003726 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
zhanghailiang48781e52015-12-16 11:47:33 +00003727 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3728 MIGRATION_STATUS_ACTIVE);
Michael R. Hines29ae8a42013-07-22 10:01:57 -04003729
Dr. David Alan Gilbert9ec055a2015-11-05 18:10:58 +00003730 trace_migration_thread_setup_complete();
3731
Wei Yang8f8d5282019-07-17 08:53:41 +08003732 while (migration_is_active(s)) {
Dr. David Alan Gilbertad767be2018-06-13 11:26:41 +01003733 if (urgent || !qemu_file_rate_limit(s->to_dst_file)) {
Peter Xu2ad87302018-01-03 20:20:14 +08003734 MigIterateState iter_state = migration_iteration_run(s);
3735 if (iter_state == MIG_ITERATE_SKIP) {
3736 continue;
3737 } else if (iter_state == MIG_ITERATE_BREAK) {
Dr. David Alan Gilbert09f6c852015-08-13 11:51:31 +01003738 break;
Juan Quintelac369f402012-10-03 20:33:34 +02003739 }
3740 }
Paolo Bonzinif4410a52013-02-22 17:36:20 +01003741
Peter Xub23c2ad2018-05-02 18:47:19 +08003742 /*
3743 * Try to detect any kind of failures, and see whether we
3744 * should stop the migration now.
3745 */
3746 thr_error = migration_detect_error(s);
3747 if (thr_error == MIG_THR_ERR_FATAL) {
3748 /* Stop migration */
Paolo Bonzinifd45ee22013-02-22 17:36:33 +01003749 break;
Peter Xub23c2ad2018-05-02 18:47:19 +08003750 } else if (thr_error == MIG_THR_ERR_RECOVERED) {
3751 /*
3752 * Just recovered from a e.g. network failure, reset all
3753 * the local variables. This is important to avoid
3754 * breaking transferred_bytes and bandwidth calculation
3755 */
Ivan Ren87f3bd82019-08-02 18:18:41 +08003756 update_iteration_initial_status(s);
Paolo Bonzinifd45ee22013-02-22 17:36:33 +01003757 }
Peter Xub15df1a2018-01-03 20:20:13 +08003758
Dr. David Alan Gilbert97e1e062019-12-05 10:29:18 +00003759 urgent = migration_rate_limit();
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +01003760 }
3761
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003762 trace_migration_thread_after_loop();
Peter Xu199aa6d2018-01-03 20:20:15 +08003763 migration_iteration_finish(s);
Dr. David Alan Gilbert892ae712019-02-27 16:49:00 +00003764 object_unref(OBJECT(s));
Paolo Bonziniab28bd22015-07-09 08:55:38 +02003765 rcu_unregister_thread();
Juan Quintela0d82d0e2012-10-03 14:18:33 +02003766 return NULL;
3767}
3768
Andrey Gruzdev85182782021-01-29 13:14:06 +03003769static void bg_migration_vm_start_bh(void *opaque)
3770{
3771 MigrationState *s = opaque;
3772
3773 qemu_bh_delete(s->vm_start_bh);
3774 s->vm_start_bh = NULL;
3775
3776 vm_start();
3777 s->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - s->downtime_start;
3778}
3779
3780/**
3781 * Background snapshot thread, based on live migration code.
3782 * This is an alternative implementation of live migration mechanism
3783 * introduced specifically to support background snapshots.
3784 *
3785 * It takes advantage of userfault_fd write protection mechanism introduced
3786 * in v5.7 kernel. Compared to existing dirty page logging migration much
3787 * lesser stream traffic is produced resulting in smaller snapshot images,
3788 * simply cause of no page duplicates can get into the stream.
3789 *
3790 * Another key point is that generated vmstate stream reflects machine state
3791 * 'frozen' at the beginning of snapshot creation compared to dirty page logging
3792 * mechanism, which effectively results in that saved snapshot is the state of VM
3793 * at the end of the process.
3794 */
3795static void *bg_migration_thread(void *opaque)
3796{
3797 MigrationState *s = opaque;
3798 int64_t setup_start;
3799 MigThrError thr_error;
3800 QEMUFile *fb;
3801 bool early_fail = true;
3802
3803 rcu_register_thread();
3804 object_ref(OBJECT(s));
3805
3806 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
3807
3808 setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
3809 /*
3810 * We want to save vmstate for the moment when migration has been
3811 * initiated but also we want to save RAM content while VM is running.
3812 * The RAM content should appear first in the vmstate. So, we first
3813 * stash the non-RAM part of the vmstate to the temporary buffer,
3814 * then write RAM part of the vmstate to the migration stream
3815 * with vCPUs running and, finally, write stashed non-RAM part of
3816 * the vmstate from the buffer to the migration stream.
3817 */
Andrey Gruzdevecb23ef2021-04-01 12:22:23 +03003818 s->bioc = qio_channel_buffer_new(512 * 1024);
Andrey Gruzdev85182782021-01-29 13:14:06 +03003819 qio_channel_set_name(QIO_CHANNEL(s->bioc), "vmstate-buffer");
3820 fb = qemu_fopen_channel_output(QIO_CHANNEL(s->bioc));
3821 object_unref(OBJECT(s->bioc));
3822
3823 update_iteration_initial_status(s);
3824
Andrey Gruzdeveeccb992021-04-01 12:22:25 +03003825 /*
3826 * Prepare for tracking memory writes with UFFD-WP - populate
3827 * RAM pages before protecting.
3828 */
3829#ifdef __linux__
3830 ram_write_tracking_prepare();
3831#endif
3832
Andrey Gruzdev85182782021-01-29 13:14:06 +03003833 qemu_savevm_state_header(s->to_dst_file);
3834 qemu_savevm_state_setup(s->to_dst_file);
3835
3836 if (qemu_savevm_state_guest_unplug_pending()) {
3837 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3838 MIGRATION_STATUS_WAIT_UNPLUG);
3839
3840 while (s->state == MIGRATION_STATUS_WAIT_UNPLUG &&
3841 qemu_savevm_state_guest_unplug_pending()) {
3842 qemu_sem_timedwait(&s->wait_unplug_sem, 250);
3843 }
3844
3845 migrate_set_state(&s->state, MIGRATION_STATUS_WAIT_UNPLUG,
3846 MIGRATION_STATUS_ACTIVE);
3847 } else {
3848 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3849 MIGRATION_STATUS_ACTIVE);
3850 }
3851 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
3852
3853 trace_migration_thread_setup_complete();
3854 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3855
3856 qemu_mutex_lock_iothread();
3857
3858 /*
3859 * If VM is currently in suspended state, then, to make a valid runstate
3860 * transition in vm_stop_force_state() we need to wakeup it up.
3861 */
3862 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
3863 s->vm_was_running = runstate_is_running();
3864
3865 if (global_state_store()) {
3866 goto fail;
3867 }
3868 /* Forcibly stop VM before saving state of vCPUs and devices */
3869 if (vm_stop_force_state(RUN_STATE_PAUSED)) {
3870 goto fail;
3871 }
3872 /*
3873 * Put vCPUs in sync with shadow context structures, then
3874 * save their state to channel-buffer along with devices.
3875 */
3876 cpu_synchronize_all_states();
3877 if (qemu_savevm_state_complete_precopy_non_iterable(fb, false, false)) {
3878 goto fail;
3879 }
Andrey Gruzdevecb23ef2021-04-01 12:22:23 +03003880 /*
3881 * Since we are going to get non-iterable state data directly
3882 * from s->bioc->data, explicit flush is needed here.
3883 */
3884 qemu_fflush(fb);
3885
Andrey Gruzdev85182782021-01-29 13:14:06 +03003886 /* Now initialize UFFD context and start tracking RAM writes */
3887 if (ram_write_tracking_start()) {
3888 goto fail;
3889 }
3890 early_fail = false;
3891
3892 /*
3893 * Start VM from BH handler to avoid write-fault lock here.
3894 * UFFD-WP protection for the whole RAM is already enabled so
3895 * calling VM state change notifiers from vm_start() would initiate
3896 * writes to virtio VQs memory which is in write-protected region.
3897 */
3898 s->vm_start_bh = qemu_bh_new(bg_migration_vm_start_bh, s);
3899 qemu_bh_schedule(s->vm_start_bh);
3900
3901 qemu_mutex_unlock_iothread();
3902
3903 while (migration_is_active(s)) {
3904 MigIterateState iter_state = bg_migration_iteration_run(s);
3905 if (iter_state == MIG_ITERATE_SKIP) {
3906 continue;
3907 } else if (iter_state == MIG_ITERATE_BREAK) {
3908 break;
3909 }
3910
3911 /*
3912 * Try to detect any kind of failures, and see whether we
3913 * should stop the migration now.
3914 */
3915 thr_error = migration_detect_error(s);
3916 if (thr_error == MIG_THR_ERR_FATAL) {
3917 /* Stop migration */
3918 break;
3919 }
3920
3921 migration_update_counters(s, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
3922 }
3923
3924 trace_migration_thread_after_loop();
3925
3926fail:
3927 if (early_fail) {
3928 migrate_set_state(&s->state, MIGRATION_STATUS_ACTIVE,
3929 MIGRATION_STATUS_FAILED);
3930 qemu_mutex_unlock_iothread();
3931 }
3932
3933 bg_migration_iteration_finish(s);
3934
3935 qemu_fclose(fb);
3936 object_unref(OBJECT(s));
3937 rcu_unregister_thread();
3938
3939 return NULL;
3940}
3941
Dr. David Alan Gilbertcce80402017-12-15 17:16:54 +00003942void migrate_fd_connect(MigrationState *s, Error *error_in)
Juan Quintela0d82d0e2012-10-03 14:18:33 +02003943{
Juan Quintela00f4b572019-06-12 11:33:27 +02003944 Error *local_err = NULL;
Peter Xud3e35b82018-05-02 18:47:24 +08003945 int64_t rate_limit;
3946 bool resume = s->state == MIGRATION_STATUS_POSTCOPY_PAUSED;
3947
Ashijeet Acharya2ff30252016-09-15 21:50:28 +05303948 s->expected_downtime = s->parameters.downtime_limit;
Marc-André Lureau9cbc3642020-03-25 19:47:21 +01003949 if (resume) {
3950 assert(s->cleanup_bh);
3951 } else {
3952 assert(!s->cleanup_bh);
3953 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup_bh, s);
3954 }
Dr. David Alan Gilbertcce80402017-12-15 17:16:54 +00003955 if (error_in) {
3956 migrate_fd_error(s, error_in);
3957 migrate_fd_cleanup(s);
3958 return;
3959 }
Juan Quintela0d82d0e2012-10-03 14:18:33 +02003960
Peter Xud3e35b82018-05-02 18:47:24 +08003961 if (resume) {
3962 /* This is a resumed migration */
Peter Xu8504dde2019-09-06 21:01:03 +08003963 rate_limit = s->parameters.max_postcopy_bandwidth /
3964 XFER_LIMIT_RATIO;
Peter Xud3e35b82018-05-02 18:47:24 +08003965 } else {
3966 /* This is a fresh new migration */
3967 rate_limit = s->parameters.max_bandwidth / XFER_LIMIT_RATIO;
Paolo Bonzini442773c2013-02-22 17:36:44 +01003968
Peter Xud3e35b82018-05-02 18:47:24 +08003969 /* Notify before starting migration thread */
3970 notifier_list_notify(&migration_state_notifiers, s);
3971 }
3972
3973 qemu_file_set_rate_limit(s->to_dst_file, rate_limit);
3974 qemu_file_set_blocking(s->to_dst_file, true);
Stefan Hajnoczi9287ac22013-07-29 15:01:57 +02003975
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003976 /*
Peter Xuc788ada2017-06-26 18:28:55 +08003977 * Open the return path. For postcopy, it is used exclusively. For
3978 * precopy, only if user specified "return-path" capability would
3979 * QEMU uses the return path.
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003980 */
Peter Xuc788ada2017-06-26 18:28:55 +08003981 if (migrate_postcopy_ram() || migrate_use_return_path()) {
Peter Xud3e35b82018-05-02 18:47:24 +08003982 if (open_return_path_on_source(s, !resume)) {
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003983 error_report("Unable to open return-path for postcopy");
Peter Xud3e35b82018-05-02 18:47:24 +08003984 migrate_set_state(&s->state, s->state, MIGRATION_STATUS_FAILED);
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00003985 migrate_fd_cleanup(s);
3986 return;
3987 }
3988 }
3989
Peter Xud3e35b82018-05-02 18:47:24 +08003990 if (resume) {
Peter Xu135b87b2018-05-02 18:47:25 +08003991 /* Wakeup the main migration thread to do the recovery */
3992 migrate_set_state(&s->state, MIGRATION_STATUS_POSTCOPY_PAUSED,
3993 MIGRATION_STATUS_POSTCOPY_RECOVER);
3994 qemu_sem_post(&s->postcopy_pause_sem);
Peter Xud3e35b82018-05-02 18:47:24 +08003995 return;
3996 }
3997
Juan Quintela00f4b572019-06-12 11:33:27 +02003998 if (multifd_save_setup(&local_err) != 0) {
3999 error_report_err(local_err);
Juan Quintelaf986c3d2016-01-14 16:52:55 +01004000 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
4001 MIGRATION_STATUS_FAILED);
4002 migrate_fd_cleanup(s);
4003 return;
4004 }
Andrey Gruzdev85182782021-01-29 13:14:06 +03004005
4006 if (migrate_background_snapshot()) {
4007 qemu_thread_create(&s->thread, "bg_snapshot",
4008 bg_migration_thread, s, QEMU_THREAD_JOINABLE);
4009 } else {
4010 qemu_thread_create(&s->thread, "live_migration",
4011 migration_thread, s, QEMU_THREAD_JOINABLE);
4012 }
Dr. David Alan Gilbert1d34e4b2015-11-05 18:11:05 +00004013 s->migration_thread_running = true;
Juan Quintela0d82d0e2012-10-03 14:18:33 +02004014}
Dr. David Alan Gilbert093e3c42015-11-05 18:10:52 +00004015
Peter Xu9d18af92017-06-27 12:10:19 +08004016void migration_global_dump(Monitor *mon)
4017{
4018 MigrationState *ms = migrate_get_current();
4019
Juan Quintela6f0f6422017-10-26 11:49:57 +02004020 monitor_printf(mon, "globals:\n");
4021 monitor_printf(mon, "store-global-state: %s\n",
4022 ms->store_global_state ? "on" : "off");
4023 monitor_printf(mon, "only-migratable: %s\n",
Markus Armbruster811f8652019-04-01 11:08:24 +02004024 only_migratable ? "on" : "off");
Juan Quintela6f0f6422017-10-26 11:49:57 +02004025 monitor_printf(mon, "send-configuration: %s\n",
4026 ms->send_configuration ? "on" : "off");
4027 monitor_printf(mon, "send-section-footer: %s\n",
4028 ms->send_section_footer ? "on" : "off");
Xiao Guangrongf5482222018-05-03 16:06:11 +08004029 monitor_printf(mon, "decompress-error-check: %s\n",
4030 ms->decompress_error_check ? "on" : "off");
Peter Xu002cad62019-06-03 14:50:56 +08004031 monitor_printf(mon, "clear-bitmap-shift: %u\n",
4032 ms->clear_bitmap_shift);
Peter Xu9d18af92017-06-27 12:10:19 +08004033}
4034
Peter Xu20814752017-07-18 11:39:03 +08004035#define DEFINE_PROP_MIG_CAP(name, x) \
4036 DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false)
4037
Peter Xu52722982017-06-27 12:10:14 +08004038static Property migration_properties[] = {
4039 DEFINE_PROP_BOOL("store-global-state", MigrationState,
4040 store_global_state, true),
Peter Xu71dd4c12017-06-27 12:10:16 +08004041 DEFINE_PROP_BOOL("send-configuration", MigrationState,
4042 send_configuration, true),
Peter Xu15c38502017-06-27 12:10:17 +08004043 DEFINE_PROP_BOOL("send-section-footer", MigrationState,
4044 send_section_footer, true),
Xiao Guangrongf5482222018-05-03 16:06:11 +08004045 DEFINE_PROP_BOOL("decompress-error-check", MigrationState,
4046 decompress_error_check, true),
Peter Xu002cad62019-06-03 14:50:56 +08004047 DEFINE_PROP_UINT8("x-clear-bitmap-shift", MigrationState,
4048 clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT),
Peter Xu89632fa2017-07-18 11:39:02 +08004049
4050 /* Migration parameters */
Juan Quintela741d4082017-12-01 13:08:38 +01004051 DEFINE_PROP_UINT8("x-compress-level", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004052 parameters.compress_level,
4053 DEFAULT_MIGRATE_COMPRESS_LEVEL),
Juan Quintela741d4082017-12-01 13:08:38 +01004054 DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004055 parameters.compress_threads,
4056 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
Xiao Guangrong1d588722018-08-21 16:10:20 +08004057 DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState,
4058 parameters.compress_wait_thread, true),
Juan Quintela741d4082017-12-01 13:08:38 +01004059 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004060 parameters.decompress_threads,
4061 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
Keqian Zhudc14a472020-02-24 10:31:42 +08004062 DEFINE_PROP_UINT8("x-throttle-trigger-threshold", MigrationState,
4063 parameters.throttle_trigger_threshold,
4064 DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD),
Juan Quintela741d4082017-12-01 13:08:38 +01004065 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004066 parameters.cpu_throttle_initial,
4067 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
Juan Quintela741d4082017-12-01 13:08:38 +01004068 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004069 parameters.cpu_throttle_increment,
4070 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
Keqian Zhucbbf8182020-04-13 18:15:08 +08004071 DEFINE_PROP_BOOL("x-cpu-throttle-tailslow", MigrationState,
4072 parameters.cpu_throttle_tailslow, false),
Juan Quintela741d4082017-12-01 13:08:38 +01004073 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004074 parameters.max_bandwidth, MAX_THROTTLE),
Juan Quintela741d4082017-12-01 13:08:38 +01004075 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004076 parameters.downtime_limit,
4077 DEFAULT_MIGRATE_SET_DOWNTIME),
Juan Quintela741d4082017-12-01 13:08:38 +01004078 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
Peter Xu89632fa2017-07-18 11:39:02 +08004079 parameters.x_checkpoint_delay,
4080 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
Juan Quintelacbfd6c92019-02-06 13:54:06 +01004081 DEFINE_PROP_UINT8("multifd-channels", MigrationState,
4082 parameters.multifd_channels,
Juan Quintela4075fb12016-01-15 08:56:17 +01004083 DEFAULT_MIGRATE_MULTIFD_CHANNELS),
Juan Quintela96eef042019-01-16 10:35:55 +01004084 DEFINE_PROP_MULTIFD_COMPRESSION("multifd-compression", MigrationState,
4085 parameters.multifd_compression,
4086 DEFAULT_MIGRATE_MULTIFD_COMPRESSION),
Juan Quintela9004db42020-01-23 17:08:52 +01004087 DEFINE_PROP_UINT8("multifd-zlib-level", MigrationState,
4088 parameters.multifd_zlib_level,
4089 DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL),
Juan Quintela6a9ad152020-01-23 17:41:36 +01004090 DEFINE_PROP_UINT8("multifd-zstd-level", MigrationState,
4091 parameters.multifd_zstd_level,
4092 DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL),
Juan Quintela73af8dd2017-10-05 21:30:10 +02004093 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
4094 parameters.xbzrle_cache_size,
4095 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01004096 DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState,
4097 parameters.max_postcopy_bandwidth,
4098 DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH),
Li Qiang4cbc9c72018-08-01 06:00:20 -07004099 DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,
4100 parameters.max_cpu_throttle,
4101 DEFAULT_MIGRATE_MAX_CPU_THROTTLE),
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00004102 DEFINE_PROP_SIZE("announce-initial", MigrationState,
4103 parameters.announce_initial,
4104 DEFAULT_MIGRATE_ANNOUNCE_INITIAL),
4105 DEFINE_PROP_SIZE("announce-max", MigrationState,
4106 parameters.announce_max,
4107 DEFAULT_MIGRATE_ANNOUNCE_MAX),
4108 DEFINE_PROP_SIZE("announce-rounds", MigrationState,
4109 parameters.announce_rounds,
4110 DEFAULT_MIGRATE_ANNOUNCE_ROUNDS),
4111 DEFINE_PROP_SIZE("announce-step", MigrationState,
4112 parameters.announce_step,
4113 DEFAULT_MIGRATE_ANNOUNCE_STEP),
Peter Xu20814752017-07-18 11:39:03 +08004114
4115 /* Migration capabilities */
4116 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
4117 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
4118 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
4119 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
4120 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
4121 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
4122 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
4123 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
4124 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
4125 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
4126 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
Juan Quintelacbfd6c92019-02-06 13:54:06 +01004127 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_MULTIFD),
Andrey Gruzdev6e8c25b2021-01-29 13:14:03 +03004128 DEFINE_PROP_MIG_CAP("x-background-snapshot",
4129 MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT),
Peter Xu20814752017-07-18 11:39:03 +08004130
Peter Xu52722982017-06-27 12:10:14 +08004131 DEFINE_PROP_END_OF_LIST(),
4132};
4133
Peter Xue5cb7e72017-06-27 12:10:13 +08004134static void migration_class_init(ObjectClass *klass, void *data)
4135{
4136 DeviceClass *dc = DEVICE_CLASS(klass);
4137
4138 dc->user_creatable = false;
Marc-André Lureau4f67d302020-01-10 19:30:32 +04004139 device_class_set_props(dc, migration_properties);
Peter Xue5cb7e72017-06-27 12:10:13 +08004140}
4141
Marc-André Lureaub91bf5e2017-08-01 17:04:18 +01004142static void migration_instance_finalize(Object *obj)
4143{
4144 MigrationState *ms = MIGRATION_OBJ(obj);
4145 MigrationParameters *params = &ms->parameters;
4146
Juan Quintela87db1a72017-09-05 12:50:22 +02004147 qemu_mutex_destroy(&ms->error_mutex);
Peter Xu62df0662018-05-02 18:47:38 +08004148 qemu_mutex_destroy(&ms->qemu_file_lock);
Marc-André Lureaub91bf5e2017-08-01 17:04:18 +01004149 g_free(params->tls_hostname);
4150 g_free(params->tls_creds);
Jens Freimannc7e0acd2019-10-29 12:49:02 +01004151 qemu_sem_destroy(&ms->wait_unplug_sem);
Dr. David Alan Gilbertad767be2018-06-13 11:26:41 +01004152 qemu_sem_destroy(&ms->rate_limit_sem);
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01004153 qemu_sem_destroy(&ms->pause_sem);
Peter Xub23c2ad2018-05-02 18:47:19 +08004154 qemu_sem_destroy(&ms->postcopy_pause_sem);
Peter Xu14b17422018-05-02 18:47:21 +08004155 qemu_sem_destroy(&ms->postcopy_pause_rp_sem);
Peter Xuedd090c2018-05-02 18:47:32 +08004156 qemu_sem_destroy(&ms->rp_state.rp_sem);
Marc-André Lureauab105cc2018-03-06 18:09:59 +01004157 error_free(ms->error);
Marc-André Lureaub91bf5e2017-08-01 17:04:18 +01004158}
4159
Peter Xue5cb7e72017-06-27 12:10:13 +08004160static void migration_instance_init(Object *obj)
4161{
4162 MigrationState *ms = MIGRATION_OBJ(obj);
Peter Xu8b0b29d2017-07-18 11:39:06 +08004163 MigrationParameters *params = &ms->parameters;
Peter Xue5cb7e72017-06-27 12:10:13 +08004164
4165 ms->state = MIGRATION_STATUS_NONE;
Peter Xue5cb7e72017-06-27 12:10:13 +08004166 ms->mbps = -1;
Xiao Guangrongaecbfe92019-01-11 14:37:30 +08004167 ms->pages_per_second = -1;
Dr. David Alan Gilberte91d8952017-10-20 10:05:52 +01004168 qemu_sem_init(&ms->pause_sem, 0);
Juan Quintela87db1a72017-09-05 12:50:22 +02004169 qemu_mutex_init(&ms->error_mutex);
Peter Xu8b0b29d2017-07-18 11:39:06 +08004170
4171 params->tls_hostname = g_strdup("");
4172 params->tls_creds = g_strdup("");
4173
4174 /* Set has_* up only for parameter checks */
4175 params->has_compress_level = true;
4176 params->has_compress_threads = true;
4177 params->has_decompress_threads = true;
Keqian Zhudc14a472020-02-24 10:31:42 +08004178 params->has_throttle_trigger_threshold = true;
Peter Xu8b0b29d2017-07-18 11:39:06 +08004179 params->has_cpu_throttle_initial = true;
4180 params->has_cpu_throttle_increment = true;
Keqian Zhucbbf8182020-04-13 18:15:08 +08004181 params->has_cpu_throttle_tailslow = true;
Peter Xu8b0b29d2017-07-18 11:39:06 +08004182 params->has_max_bandwidth = true;
4183 params->has_downtime_limit = true;
4184 params->has_x_checkpoint_delay = true;
4185 params->has_block_incremental = true;
Juan Quintelacbfd6c92019-02-06 13:54:06 +01004186 params->has_multifd_channels = true;
Juan Quintela96eef042019-01-16 10:35:55 +01004187 params->has_multifd_compression = true;
Juan Quintela9004db42020-01-23 17:08:52 +01004188 params->has_multifd_zlib_level = true;
Juan Quintela6a9ad152020-01-23 17:41:36 +01004189 params->has_multifd_zstd_level = true;
Juan Quintela73af8dd2017-10-05 21:30:10 +02004190 params->has_xbzrle_cache_size = true;
Dr. David Alan Gilbert7e555c62018-06-13 11:26:40 +01004191 params->has_max_postcopy_bandwidth = true;
Li Qiang4cbc9c72018-08-01 06:00:20 -07004192 params->has_max_cpu_throttle = true;
Dr. David Alan Gilbertee3d96b2019-02-27 13:24:06 +00004193 params->has_announce_initial = true;
4194 params->has_announce_max = true;
4195 params->has_announce_rounds = true;
4196 params->has_announce_step = true;
Peter Xub23c2ad2018-05-02 18:47:19 +08004197
4198 qemu_sem_init(&ms->postcopy_pause_sem, 0);
Peter Xu14b17422018-05-02 18:47:21 +08004199 qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);
Peter Xuedd090c2018-05-02 18:47:32 +08004200 qemu_sem_init(&ms->rp_state.rp_sem, 0);
Dr. David Alan Gilbertad767be2018-06-13 11:26:41 +01004201 qemu_sem_init(&ms->rate_limit_sem, 0);
Jens Freimannc7e0acd2019-10-29 12:49:02 +01004202 qemu_sem_init(&ms->wait_unplug_sem, 0);
Peter Xu62df0662018-05-02 18:47:38 +08004203 qemu_mutex_init(&ms->qemu_file_lock);
Peter Xu8b0b29d2017-07-18 11:39:06 +08004204}
4205
4206/*
4207 * Return true if check pass, false otherwise. Error will be put
4208 * inside errp if provided.
4209 */
4210static bool migration_object_check(MigrationState *ms, Error **errp)
4211{
Peter Xu6b19a7d2017-07-18 11:39:10 +08004212 MigrationCapabilityStatusList *head = NULL;
4213 /* Assuming all off */
4214 bool cap_list[MIGRATION_CAPABILITY__MAX] = { 0 }, ret;
4215 int i;
4216
Peter Xu8b0b29d2017-07-18 11:39:06 +08004217 if (!migrate_params_check(&ms->parameters, errp)) {
4218 return false;
4219 }
4220
Peter Xu6b19a7d2017-07-18 11:39:10 +08004221 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
4222 if (ms->enabled_capabilities[i]) {
Eric Blakeeaedde52020-11-12 19:13:36 -06004223 QAPI_LIST_PREPEND(head, migrate_cap_add(i, true));
Peter Xu6b19a7d2017-07-18 11:39:10 +08004224 }
4225 }
4226
4227 ret = migrate_caps_check(cap_list, head, errp);
4228
4229 /* It works with head == NULL */
4230 qapi_free_MigrationCapabilityStatusList(head);
4231
4232 return ret;
Peter Xue5cb7e72017-06-27 12:10:13 +08004233}
4234
4235static const TypeInfo migration_type = {
4236 .name = TYPE_MIGRATION,
Peter Xu01f6e142017-06-28 15:15:44 +08004237 /*
Peter Xuc8d3ff32017-07-05 16:21:23 +08004238 * NOTE: TYPE_MIGRATION is not really a device, as the object is
Markus Armbruster2194abd2020-06-10 07:32:19 +02004239 * not created using qdev_new(), it is not attached to the qdev
Peter Xuc8d3ff32017-07-05 16:21:23 +08004240 * device tree, and it is never realized.
4241 *
4242 * TODO: Make this TYPE_OBJECT once QOM provides something like
4243 * TYPE_DEVICE's "-global" properties.
Peter Xu01f6e142017-06-28 15:15:44 +08004244 */
Peter Xue5cb7e72017-06-27 12:10:13 +08004245 .parent = TYPE_DEVICE,
4246 .class_init = migration_class_init,
4247 .class_size = sizeof(MigrationClass),
4248 .instance_size = sizeof(MigrationState),
4249 .instance_init = migration_instance_init,
Marc-André Lureaub91bf5e2017-08-01 17:04:18 +01004250 .instance_finalize = migration_instance_finalize,
Peter Xue5cb7e72017-06-27 12:10:13 +08004251};
4252
4253static void register_migration_types(void)
4254{
4255 type_register_static(&migration_type);
4256}
4257
4258type_init(register_migration_types);