blob: 8d675b31a1792a0e0ed174b1844354fe9efdcd8c [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
16#include "qemu-common.h"
Alex Bligh6a1751b2013-08-21 16:02:47 +010017#include "qemu/main-loop.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010018#include "migration/migration.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010019#include "monitor/monitor.h"
Juan Quintela0d82d0e2012-10-03 14:18:33 +020020#include "migration/qemu-file.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010021#include "sysemu/sysemu.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010022#include "block/block.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010023#include "qemu/sockets.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010024#include "migration/block.h"
Juan Quintela766bd172012-07-23 05:45:29 +020025#include "qemu/thread.h"
Luiz Capitulino791e7c82011-09-13 17:37:16 -030026#include "qmp-commands.h"
Kazuya Saitoc09e5bb2013-02-22 17:36:19 +010027#include "trace.h"
aliguori065e2812008-11-11 16:46:33 +000028
Juan Quintela7dc688e2011-02-23 00:48:46 +010029enum {
Michael R. Hines29ae8a42013-07-22 10:01:57 -040030 MIG_STATE_ERROR = -1,
31 MIG_STATE_NONE,
Juan Quintela7dc688e2011-02-23 00:48:46 +010032 MIG_STATE_SETUP,
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +000033 MIG_STATE_CANCELLING,
Juan Quintela7dc688e2011-02-23 00:48:46 +010034 MIG_STATE_CANCELLED,
35 MIG_STATE_ACTIVE,
36 MIG_STATE_COMPLETED,
37};
aliguori5bb79102008-10-13 03:12:02 +000038
Juan Quintelad0ae46c2011-02-23 00:33:19 +010039#define MAX_THROTTLE (32 << 20) /* Migration speed throttling */
aliguori5bb79102008-10-13 03:12:02 +000040
Juan Quintela5b4e1eb2012-12-19 10:40:48 +010041/* Amount of time to allocate to each "chunk" of bandwidth-throttled
42 * data. */
43#define BUFFER_DELAY 100
44#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
45
Orit Wasserman17ad9b32012-08-06 21:42:53 +030046/* Migration XBZRLE default cache size */
47#define DEFAULT_MIGRATE_CACHE_SIZE (64 * 1024 * 1024)
48
Gerd Hoffmann99a0db92010-12-13 17:30:12 +010049static NotifierList migration_state_notifiers =
50 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
51
Juan Quintela17549e82011-10-05 13:50:43 +020052/* When we add fault tolerance, we could have several
53 migrations at once. For now we don't need to add
54 dynamic creation of migration */
55
Juan Quintela859bc752012-08-13 09:42:49 +020056MigrationState *migrate_get_current(void)
Juan Quintela17549e82011-10-05 13:50:43 +020057{
58 static MigrationState current_migration = {
Michael R. Hines29ae8a42013-07-22 10:01:57 -040059 .state = MIG_STATE_NONE,
Juan Quintelad0ae46c2011-02-23 00:33:19 +010060 .bandwidth_limit = MAX_THROTTLE,
Orit Wasserman17ad9b32012-08-06 21:42:53 +030061 .xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE,
Michael R. Hines7e114f82013-06-25 21:35:30 -040062 .mbps = -1,
Juan Quintela17549e82011-10-05 13:50:43 +020063 };
64
65 return &current_migration;
66}
67
Paolo Bonzini43eaae22012-10-02 18:21:18 +020068void qemu_start_incoming_migration(const char *uri, Error **errp)
aliguori5bb79102008-10-13 03:12:02 +000069{
aliguori34c9dd82008-10-13 03:14:31 +000070 const char *p;
71
72 if (strstart(uri, "tcp:", &p))
Paolo Bonzini43eaae22012-10-02 18:21:18 +020073 tcp_start_incoming_migration(p, errp);
Michael R. Hines2da776d2013-07-22 10:01:54 -040074#ifdef CONFIG_RDMA
Michael R. Hines41310c62013-12-19 04:52:01 +080075 else if (strstart(uri, "rdma:", &p))
Michael R. Hines2da776d2013-07-22 10:01:54 -040076 rdma_start_incoming_migration(p, errp);
77#endif
aliguori065e2812008-11-11 16:46:33 +000078#if !defined(WIN32)
79 else if (strstart(uri, "exec:", &p))
Paolo Bonzini43eaae22012-10-02 18:21:18 +020080 exec_start_incoming_migration(p, errp);
Chris Lalancette4951f652009-08-05 17:24:29 +020081 else if (strstart(uri, "unix:", &p))
Paolo Bonzini43eaae22012-10-02 18:21:18 +020082 unix_start_incoming_migration(p, errp);
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +020083 else if (strstart(uri, "fd:", &p))
Paolo Bonzini43eaae22012-10-02 18:21:18 +020084 fd_start_incoming_migration(p, errp);
aliguori065e2812008-11-11 16:46:33 +000085#endif
Juan Quintela8ca5e802010-06-09 14:10:54 +020086 else {
Markus Armbruster312fd5f2013-02-08 21:22:16 +010087 error_setg(errp, "unknown migration protocol: %s", uri);
Juan Quintela8ca5e802010-06-09 14:10:54 +020088 }
aliguori5bb79102008-10-13 03:12:02 +000089}
90
Paolo Bonzini82a4da72012-08-07 10:57:43 +020091static void process_incoming_migration_co(void *opaque)
Juan Quintela511c0232010-06-09 14:10:55 +020092{
Paolo Bonzini82a4da72012-08-07 10:57:43 +020093 QEMUFile *f = opaque;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +010094 Error *local_err = NULL;
Paolo Bonzini1c12e1f2012-08-07 10:51:51 +020095 int ret;
96
97 ret = qemu_loadvm_state(f);
98 qemu_fclose(f);
Gonglei (Arei)905f26f2014-01-30 20:08:35 +020099 free_xbzrle_decoded_buf();
Paolo Bonzini1c12e1f2012-08-07 10:51:51 +0200100 if (ret < 0) {
Peter Lievendb80fac2014-06-10 11:29:16 +0200101 error_report("load of migration failed: %s", strerror(-ret));
Eric Blake4aead692013-04-16 15:50:41 -0600102 exit(EXIT_FAILURE);
Juan Quintela511c0232010-06-09 14:10:55 +0200103 }
104 qemu_announce_self();
Juan Quintela511c0232010-06-09 14:10:55 +0200105
BenoƮt Canet901862c2012-03-23 08:36:52 +0100106 bdrv_clear_incoming_migration_all();
Anthony Liguori0f154232011-11-14 15:09:45 -0600107 /* Make sure all file formats flush their mutable metadata */
Kevin Wolf5a8a30d2014-03-12 15:59:16 +0100108 bdrv_invalidate_cache_all(&local_err);
109 if (local_err) {
110 qerror_report_err(local_err);
111 error_free(local_err);
112 exit(EXIT_FAILURE);
113 }
Anthony Liguori0f154232011-11-14 15:09:45 -0600114
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300115 if (autostart) {
Juan Quintela511c0232010-06-09 14:10:55 +0200116 vm_start();
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300117 } else {
Paolo Bonzini29ed72f2012-10-19 16:45:24 +0200118 runstate_set(RUN_STATE_PAUSED);
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300119 }
Juan Quintela511c0232010-06-09 14:10:55 +0200120}
121
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200122void process_incoming_migration(QEMUFile *f)
123{
124 Coroutine *co = qemu_coroutine_create(process_incoming_migration_co);
125 int fd = qemu_get_fd(f);
126
127 assert(fd != -1);
Stefan Hajnoczif9e8cac2013-03-27 10:10:43 +0100128 qemu_set_nonblock(fd);
Paolo Bonzini82a4da72012-08-07 10:57:43 +0200129 qemu_coroutine_enter(co, f);
130}
131
Glauber Costaa0a3fd62009-05-28 15:22:57 -0400132/* amount of nanoseconds we are willing to wait for migration to be down.
133 * the choice of nanoseconds is because it is the maximum resolution that
134 * get_clock() can achieve. It is an internal measure. All user-visible
135 * units must be in seconds */
Alexey Kardashevskiyf7cd55a2014-03-27 14:57:26 +1100136static uint64_t max_downtime = 300000000;
Glauber Costaa0a3fd62009-05-28 15:22:57 -0400137
138uint64_t migrate_max_downtime(void)
139{
140 return max_downtime;
141}
142
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300143MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
144{
145 MigrationCapabilityStatusList *head = NULL;
146 MigrationCapabilityStatusList *caps;
147 MigrationState *s = migrate_get_current();
148 int i;
149
Michael Tokarev387eede2013-10-05 13:18:28 +0400150 caps = NULL; /* silence compiler warning */
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300151 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
152 if (head == NULL) {
153 head = g_malloc0(sizeof(*caps));
154 caps = head;
155 } else {
156 caps->next = g_malloc0(sizeof(*caps));
157 caps = caps->next;
158 }
159 caps->value =
160 g_malloc(sizeof(*caps->value));
161 caps->value->capability = i;
162 caps->value->state = s->enabled_capabilities[i];
163 }
164
165 return head;
166}
167
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300168static void get_xbzrle_cache_stats(MigrationInfo *info)
169{
170 if (migrate_use_xbzrle()) {
171 info->has_xbzrle_cache = true;
172 info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
173 info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
174 info->xbzrle_cache->bytes = xbzrle_mig_bytes_transferred();
175 info->xbzrle_cache->pages = xbzrle_mig_pages_transferred();
176 info->xbzrle_cache->cache_miss = xbzrle_mig_pages_cache_miss();
ChenLiang8bc39232014-04-04 17:57:56 +0800177 info->xbzrle_cache->cache_miss_rate = xbzrle_mig_cache_miss_rate();
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300178 info->xbzrle_cache->overflow = xbzrle_mig_pages_overflow();
179 }
180}
181
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300182MigrationInfo *qmp_query_migrate(Error **errp)
aliguori5bb79102008-10-13 03:12:02 +0000183{
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300184 MigrationInfo *info = g_malloc0(sizeof(*info));
Juan Quintela17549e82011-10-05 13:50:43 +0200185 MigrationState *s = migrate_get_current();
aliguori376253e2009-03-05 23:01:23 +0000186
Juan Quintela17549e82011-10-05 13:50:43 +0200187 switch (s->state) {
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400188 case MIG_STATE_NONE:
Juan Quintela17549e82011-10-05 13:50:43 +0200189 /* no migration has happened ever */
190 break;
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400191 case MIG_STATE_SETUP:
192 info->has_status = true;
193 info->status = g_strdup("setup");
Michael R. Hinesed4fbd12013-07-22 10:01:58 -0400194 info->has_total_time = false;
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400195 break;
Juan Quintela17549e82011-10-05 13:50:43 +0200196 case MIG_STATE_ACTIVE:
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +0000197 case MIG_STATE_CANCELLING:
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300198 info->has_status = true;
199 info->status = g_strdup("active");
Juan Quintela7aa939a2012-08-18 13:17:10 +0200200 info->has_total_time = true;
Alex Blighbc72ad62013-08-21 16:03:08 +0100201 info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
Juan Quintela7aa939a2012-08-18 13:17:10 +0200202 - s->total_time;
Juan Quintela2c52ddf2012-08-13 09:53:12 +0200203 info->has_expected_downtime = true;
204 info->expected_downtime = s->expected_downtime;
Michael R. Hinesed4fbd12013-07-22 10:01:58 -0400205 info->has_setup_time = true;
206 info->setup_time = s->setup_time;
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200207
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300208 info->has_ram = true;
209 info->ram = g_malloc0(sizeof(*info->ram));
210 info->ram->transferred = ram_bytes_transferred();
211 info->ram->remaining = ram_bytes_remaining();
212 info->ram->total = ram_bytes_total();
Orit Wasserman004d4c12012-08-06 21:42:56 +0300213 info->ram->duplicate = dup_mig_pages_transferred();
Peter Lievenf1c72792013-03-26 10:58:37 +0100214 info->ram->skipped = skipped_mig_pages_transferred();
Orit Wasserman004d4c12012-08-06 21:42:56 +0300215 info->ram->normal = norm_mig_pages_transferred();
216 info->ram->normal_bytes = norm_mig_bytes_transferred();
Juan Quintela8d017192012-08-13 12:31:25 +0200217 info->ram->dirty_pages_rate = s->dirty_pages_rate;
Michael R. Hines7e114f82013-06-25 21:35:30 -0400218 info->ram->mbps = s->mbps;
ChenLiang58570ed2014-04-04 17:57:55 +0800219 info->ram->dirty_sync_count = s->dirty_sync_count;
Juan Quintela8d017192012-08-13 12:31:25 +0200220
Juan Quintela17549e82011-10-05 13:50:43 +0200221 if (blk_mig_active()) {
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300222 info->has_disk = true;
223 info->disk = g_malloc0(sizeof(*info->disk));
224 info->disk->transferred = blk_mig_bytes_transferred();
225 info->disk->remaining = blk_mig_bytes_remaining();
226 info->disk->total = blk_mig_bytes_total();
aliguoriff8d81d2008-10-24 22:10:31 +0000227 }
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300228
229 get_xbzrle_cache_stats(info);
Juan Quintela17549e82011-10-05 13:50:43 +0200230 break;
231 case MIG_STATE_COMPLETED:
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300232 get_xbzrle_cache_stats(info);
233
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300234 info->has_status = true;
235 info->status = g_strdup("completed");
Pawit Pornkitprasan00c14992013-07-19 11:23:45 +0900236 info->has_total_time = true;
Juan Quintela7aa939a2012-08-18 13:17:10 +0200237 info->total_time = s->total_time;
Juan Quintela9c5a9fc2012-08-13 09:35:16 +0200238 info->has_downtime = true;
239 info->downtime = s->downtime;
Michael R. Hinesed4fbd12013-07-22 10:01:58 -0400240 info->has_setup_time = true;
241 info->setup_time = s->setup_time;
Juan Quintelad5f8a572012-05-21 22:01:07 +0200242
243 info->has_ram = true;
244 info->ram = g_malloc0(sizeof(*info->ram));
245 info->ram->transferred = ram_bytes_transferred();
246 info->ram->remaining = 0;
247 info->ram->total = ram_bytes_total();
Orit Wasserman004d4c12012-08-06 21:42:56 +0300248 info->ram->duplicate = dup_mig_pages_transferred();
Peter Lievenf1c72792013-03-26 10:58:37 +0100249 info->ram->skipped = skipped_mig_pages_transferred();
Orit Wasserman004d4c12012-08-06 21:42:56 +0300250 info->ram->normal = norm_mig_pages_transferred();
251 info->ram->normal_bytes = norm_mig_bytes_transferred();
Michael R. Hines7e114f82013-06-25 21:35:30 -0400252 info->ram->mbps = s->mbps;
ChenLiang58570ed2014-04-04 17:57:55 +0800253 info->ram->dirty_sync_count = s->dirty_sync_count;
Juan Quintela17549e82011-10-05 13:50:43 +0200254 break;
255 case MIG_STATE_ERROR:
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300256 info->has_status = true;
257 info->status = g_strdup("failed");
Juan Quintela17549e82011-10-05 13:50:43 +0200258 break;
259 case MIG_STATE_CANCELLED:
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300260 info->has_status = true;
261 info->status = g_strdup("cancelled");
Juan Quintela17549e82011-10-05 13:50:43 +0200262 break;
aliguori5bb79102008-10-13 03:12:02 +0000263 }
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300264
265 return info;
aliguori5bb79102008-10-13 03:12:02 +0000266}
267
Orit Wasserman00458432012-08-06 21:42:48 +0300268void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
269 Error **errp)
270{
271 MigrationState *s = migrate_get_current();
272 MigrationCapabilityStatusList *cap;
273
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400274 if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP) {
Orit Wasserman00458432012-08-06 21:42:48 +0300275 error_set(errp, QERR_MIGRATION_ACTIVE);
276 return;
277 }
278
279 for (cap = params; cap; cap = cap->next) {
280 s->enabled_capabilities[cap->value->capability] = cap->value->state;
281 }
282}
283
aliguori065e2812008-11-11 16:46:33 +0000284/* shared migration helpers */
285
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +0000286static void migrate_set_state(MigrationState *s, int old_state, int new_state)
287{
288 if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) {
289 trace_migrate_set_state(new_state);
290 }
291}
292
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100293static void migrate_fd_cleanup(void *opaque)
aliguori065e2812008-11-11 16:46:33 +0000294{
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100295 MigrationState *s = opaque;
296
297 qemu_bh_delete(s->cleanup_bh);
298 s->cleanup_bh = NULL;
299
aliguori065e2812008-11-11 16:46:33 +0000300 if (s->file) {
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100301 trace_migrate_fd_cleanup();
Paolo Bonzini404a7c02013-02-22 17:36:46 +0100302 qemu_mutex_unlock_iothread();
303 qemu_thread_join(&s->thread);
304 qemu_mutex_lock_iothread();
305
Paolo Bonzini6f190a02013-02-22 17:36:48 +0100306 qemu_fclose(s->file);
307 s->file = NULL;
aliguori065e2812008-11-11 16:46:33 +0000308 }
309
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100310 assert(s->state != MIG_STATE_ACTIVE);
Paolo Bonzini7a2c1722013-02-22 17:36:09 +0100311
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100312 if (s->state != MIG_STATE_COMPLETED) {
Paolo Bonzini7a2c1722013-02-22 17:36:09 +0100313 qemu_savevm_state_cancel();
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +0000314 if (s->state == MIG_STATE_CANCELLING) {
315 migrate_set_state(s, MIG_STATE_CANCELLING, MIG_STATE_CANCELLED);
316 }
Paolo Bonzini7a2c1722013-02-22 17:36:09 +0100317 }
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100318
319 notifier_list_notify(&migration_state_notifiers, s);
aliguori065e2812008-11-11 16:46:33 +0000320}
321
Juan Quintela8b6b99b2011-09-11 20:28:22 +0200322void migrate_fd_error(MigrationState *s)
aliguori065e2812008-11-11 16:46:33 +0000323{
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100324 trace_migrate_fd_error();
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100325 assert(s->file == NULL);
326 s->state = MIG_STATE_ERROR;
327 trace_migrate_set_state(MIG_STATE_ERROR);
328 notifier_list_notify(&migration_state_notifiers, s);
Juan Quintela458cf282011-02-22 23:32:54 +0100329}
330
Juan Quintela0edda1c2010-05-11 16:28:39 +0200331static void migrate_fd_cancel(MigrationState *s)
aliguori065e2812008-11-11 16:46:33 +0000332{
Zhanghaoyu (A)6f2b8112013-11-07 08:21:23 +0000333 int old_state ;
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100334 trace_migrate_fd_cancel();
aliguori065e2812008-11-11 16:46:33 +0000335
Zhanghaoyu (A)6f2b8112013-11-07 08:21:23 +0000336 do {
337 old_state = s->state;
338 if (old_state != MIG_STATE_SETUP && old_state != MIG_STATE_ACTIVE) {
339 break;
340 }
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +0000341 migrate_set_state(s, old_state, MIG_STATE_CANCELLING);
342 } while (s->state != MIG_STATE_CANCELLING);
aliguori065e2812008-11-11 16:46:33 +0000343}
344
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100345void add_migration_state_change_notifier(Notifier *notify)
346{
347 notifier_list_add(&migration_state_notifiers, notify);
348}
349
350void remove_migration_state_change_notifier(Notifier *notify)
351{
Paolo Bonzini31552522012-01-13 17:34:01 +0100352 notifier_remove(notify);
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100353}
354
Stefan Hajnoczi02edd2e2013-07-29 15:01:58 +0200355bool migration_in_setup(MigrationState *s)
Gerd Hoffmannafe2df62011-10-25 13:50:11 +0200356{
Stefan Hajnoczi02edd2e2013-07-29 15:01:58 +0200357 return s->state == MIG_STATE_SETUP;
Gerd Hoffmannafe2df62011-10-25 13:50:11 +0200358}
359
Juan Quintela70736932011-02-23 00:43:59 +0100360bool migration_has_finished(MigrationState *s)
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100361{
Juan Quintela70736932011-02-23 00:43:59 +0100362 return s->state == MIG_STATE_COMPLETED;
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100363}
Juan Quintela0edda1c2010-05-11 16:28:39 +0200364
Gerd Hoffmannafe2df62011-10-25 13:50:11 +0200365bool migration_has_failed(MigrationState *s)
366{
367 return (s->state == MIG_STATE_CANCELLED ||
368 s->state == MIG_STATE_ERROR);
369}
370
Isaku Yamahata6607ae22012-06-19 18:43:09 +0300371static MigrationState *migrate_init(const MigrationParams *params)
Juan Quintela0edda1c2010-05-11 16:28:39 +0200372{
Juan Quintela17549e82011-10-05 13:50:43 +0200373 MigrationState *s = migrate_get_current();
Juan Quintelad0ae46c2011-02-23 00:33:19 +0100374 int64_t bandwidth_limit = s->bandwidth_limit;
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300375 bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300376 int64_t xbzrle_cache_size = s->xbzrle_cache_size;
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300377
378 memcpy(enabled_capabilities, s->enabled_capabilities,
379 sizeof(enabled_capabilities));
Juan Quintela0edda1c2010-05-11 16:28:39 +0200380
Juan Quintela17549e82011-10-05 13:50:43 +0200381 memset(s, 0, sizeof(*s));
Isaku Yamahata6607ae22012-06-19 18:43:09 +0300382 s->params = *params;
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300383 memcpy(s->enabled_capabilities, enabled_capabilities,
384 sizeof(enabled_capabilities));
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300385 s->xbzrle_cache_size = xbzrle_cache_size;
Juan Quintela1299c632011-11-09 21:29:01 +0100386
Juan Quintela0edda1c2010-05-11 16:28:39 +0200387 s->bandwidth_limit = bandwidth_limit;
Juan Quintelad5934dd2010-05-11 23:01:53 +0200388 s->state = MIG_STATE_SETUP;
Kazuya Saitoc09e5bb2013-02-22 17:36:19 +0100389 trace_migrate_set_state(MIG_STATE_SETUP);
Juan Quintela0edda1c2010-05-11 16:28:39 +0200390
Alex Blighbc72ad62013-08-21 16:03:08 +0100391 s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintela0edda1c2010-05-11 16:28:39 +0200392 return s;
393}
Juan Quintelacab30142011-02-22 23:54:21 +0100394
Anthony Liguorifa2756b2011-11-14 15:09:43 -0600395static GSList *migration_blockers;
396
397void migrate_add_blocker(Error *reason)
398{
399 migration_blockers = g_slist_prepend(migration_blockers, reason);
400}
401
402void migrate_del_blocker(Error *reason)
403{
404 migration_blockers = g_slist_remove(migration_blockers, reason);
405}
406
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200407void qmp_migrate(const char *uri, bool has_blk, bool blk,
408 bool has_inc, bool inc, bool has_detach, bool detach,
409 Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +0100410{
Paolo Bonzinibe7059c2012-10-03 14:34:33 +0200411 Error *local_err = NULL;
Juan Quintela17549e82011-10-05 13:50:43 +0200412 MigrationState *s = migrate_get_current();
Isaku Yamahata6607ae22012-06-19 18:43:09 +0300413 MigrationParams params;
Juan Quintelacab30142011-02-22 23:54:21 +0100414 const char *p;
Juan Quintelacab30142011-02-22 23:54:21 +0100415
Pawit Pornkitprasan8c0426a2013-07-30 08:39:52 +0900416 params.blk = has_blk && blk;
417 params.shared = has_inc && inc;
Isaku Yamahata6607ae22012-06-19 18:43:09 +0300418
Zhanghaoyu (A)51cf4c12013-11-07 11:01:15 +0000419 if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP ||
420 s->state == MIG_STATE_CANCELLING) {
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200421 error_set(errp, QERR_MIGRATION_ACTIVE);
422 return;
Juan Quintelacab30142011-02-22 23:54:21 +0100423 }
424
Dr. David Alan Gilbertca999932014-04-14 17:03:59 +0100425 if (runstate_check(RUN_STATE_INMIGRATE)) {
426 error_setg(errp, "Guest is waiting for an incoming migration");
427 return;
428 }
429
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200430 if (qemu_savevm_state_blocked(errp)) {
431 return;
Juan Quintelacab30142011-02-22 23:54:21 +0100432 }
433
Anthony Liguorifa2756b2011-11-14 15:09:43 -0600434 if (migration_blockers) {
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200435 *errp = error_copy(migration_blockers->data);
436 return;
Anthony Liguorifa2756b2011-11-14 15:09:43 -0600437 }
438
Isaku Yamahata6607ae22012-06-19 18:43:09 +0300439 s = migrate_init(&params);
Juan Quintelacab30142011-02-22 23:54:21 +0100440
441 if (strstart(uri, "tcp:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200442 tcp_start_outgoing_migration(s, p, &local_err);
Michael R. Hines2da776d2013-07-22 10:01:54 -0400443#ifdef CONFIG_RDMA
Michael R. Hines41310c62013-12-19 04:52:01 +0800444 } else if (strstart(uri, "rdma:", &p)) {
Michael R. Hines2da776d2013-07-22 10:01:54 -0400445 rdma_start_outgoing_migration(s, p, &local_err);
446#endif
Juan Quintelacab30142011-02-22 23:54:21 +0100447#if !defined(WIN32)
448 } else if (strstart(uri, "exec:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200449 exec_start_outgoing_migration(s, p, &local_err);
Juan Quintelacab30142011-02-22 23:54:21 +0100450 } else if (strstart(uri, "unix:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200451 unix_start_outgoing_migration(s, p, &local_err);
Juan Quintelacab30142011-02-22 23:54:21 +0100452 } else if (strstart(uri, "fd:", &p)) {
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200453 fd_start_outgoing_migration(s, p, &local_err);
Juan Quintelacab30142011-02-22 23:54:21 +0100454#endif
455 } else {
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200456 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "uri", "a valid migration protocol");
Luiz Capitulinoc9501142013-12-29 22:39:58 -0500457 s->state = MIG_STATE_ERROR;
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200458 return;
Juan Quintelacab30142011-02-22 23:54:21 +0100459 }
460
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200461 if (local_err) {
Paolo Bonzini342ab8d2012-10-02 09:59:38 +0200462 migrate_fd_error(s);
Paolo Bonzinif37afb52012-10-02 10:02:46 +0200463 error_propagate(errp, local_err);
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -0200464 return;
Juan Quintela1299c632011-11-09 21:29:01 +0100465 }
Juan Quintelacab30142011-02-22 23:54:21 +0100466}
467
Luiz Capitulino6cdedb02011-11-27 22:54:09 -0200468void qmp_migrate_cancel(Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +0100469{
Juan Quintela17549e82011-10-05 13:50:43 +0200470 migrate_fd_cancel(migrate_get_current());
Juan Quintelacab30142011-02-22 23:54:21 +0100471}
472
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300473void qmp_migrate_set_cache_size(int64_t value, Error **errp)
474{
475 MigrationState *s = migrate_get_current();
Orit Wassermanc91e6812014-01-30 20:08:34 +0200476 int64_t new_size;
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300477
478 /* Check for truncation */
479 if (value != (size_t)value) {
480 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",
481 "exceeding address space");
482 return;
483 }
484
Orit Wassermana5615b12014-01-30 20:08:36 +0200485 /* Cache should not be larger than guest ram size */
486 if (value > ram_bytes_total()) {
487 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",
488 "exceeds guest ram size ");
489 return;
490 }
491
Orit Wassermanc91e6812014-01-30 20:08:34 +0200492 new_size = xbzrle_cache_resize(value);
493 if (new_size < 0) {
494 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",
495 "is smaller than page size");
496 return;
497 }
498
499 s->xbzrle_cache_size = new_size;
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300500}
501
502int64_t qmp_query_migrate_cache_size(Error **errp)
503{
504 return migrate_xbzrle_cache_size();
505}
506
Luiz Capitulino3dc85382011-11-28 11:59:37 -0200507void qmp_migrate_set_speed(int64_t value, Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +0100508{
Juan Quintelacab30142011-02-22 23:54:21 +0100509 MigrationState *s;
510
Luiz Capitulino3dc85382011-11-28 11:59:37 -0200511 if (value < 0) {
512 value = 0;
Juan Quintelacab30142011-02-22 23:54:21 +0100513 }
Paolo Bonzini442773c2013-02-22 17:36:44 +0100514 if (value > SIZE_MAX) {
515 value = SIZE_MAX;
516 }
Juan Quintelacab30142011-02-22 23:54:21 +0100517
Juan Quintela17549e82011-10-05 13:50:43 +0200518 s = migrate_get_current();
Luiz Capitulino3dc85382011-11-28 11:59:37 -0200519 s->bandwidth_limit = value;
Paolo Bonzini442773c2013-02-22 17:36:44 +0100520 if (s->file) {
521 qemu_file_set_rate_limit(s->file, s->bandwidth_limit / XFER_LIMIT_RATIO);
522 }
Juan Quintelacab30142011-02-22 23:54:21 +0100523}
524
Luiz Capitulino4f0a9932011-11-27 23:18:01 -0200525void qmp_migrate_set_downtime(double value, Error **errp)
Juan Quintelacab30142011-02-22 23:54:21 +0100526{
Luiz Capitulino4f0a9932011-11-27 23:18:01 -0200527 value *= 1e9;
528 value = MAX(0, MIN(UINT64_MAX, value));
529 max_downtime = (uint64_t)value;
aliguori5bb79102008-10-13 03:12:02 +0000530}
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300531
Michael R. Hines60d92222013-06-25 21:35:36 -0400532bool migrate_rdma_pin_all(void)
533{
534 MigrationState *s;
535
536 s = migrate_get_current();
537
Michael R. Hines41310c62013-12-19 04:52:01 +0800538 return s->enabled_capabilities[MIGRATION_CAPABILITY_RDMA_PIN_ALL];
Michael R. Hines60d92222013-06-25 21:35:36 -0400539}
540
Chegu Vinodbde1e2e2013-06-24 03:49:42 -0600541bool migrate_auto_converge(void)
542{
543 MigrationState *s;
544
545 s = migrate_get_current();
546
547 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
548}
549
Peter Lieven323004a2013-07-18 09:48:50 +0200550bool migrate_zero_blocks(void)
551{
552 MigrationState *s;
553
554 s = migrate_get_current();
555
556 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
557}
558
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300559int migrate_use_xbzrle(void)
560{
561 MigrationState *s;
562
563 s = migrate_get_current();
564
565 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
566}
567
568int64_t migrate_xbzrle_cache_size(void)
569{
570 MigrationState *s;
571
572 s = migrate_get_current();
573
574 return s->xbzrle_cache_size;
575}
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200576
577/* migration thread support */
578
Juan Quintela5f496a12013-02-22 17:36:30 +0100579static void *migration_thread(void *opaque)
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200580{
Juan Quintela9848a402012-12-19 09:55:50 +0100581 MigrationState *s = opaque;
Alex Blighbc72ad62013-08-21 16:03:08 +0100582 int64_t initial_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
583 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
Paolo Bonzinibe7172e2013-02-22 17:36:43 +0100584 int64_t initial_bytes = 0;
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200585 int64_t max_size = 0;
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100586 int64_t start_time = initial_time;
587 bool old_vm_running = false;
Juan Quintela76f59332012-10-03 20:16:24 +0200588
Paolo Bonzinidba433c2013-02-22 17:36:17 +0100589 qemu_savevm_state_begin(s->file, &s->params);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200590
Alex Blighbc72ad62013-08-21 16:03:08 +0100591 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400592 migrate_set_state(s, MIG_STATE_SETUP, MIG_STATE_ACTIVE);
593
Paolo Bonzinidba433c2013-02-22 17:36:17 +0100594 while (s->state == MIG_STATE_ACTIVE) {
Juan Quintelaa3e879c2013-02-01 12:39:08 +0100595 int64_t current_time;
Juan Quintelac369f402012-10-03 20:33:34 +0200596 uint64_t pending_size;
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200597
Paolo Bonzinia0ff0442013-02-22 17:36:35 +0100598 if (!qemu_file_rate_limit(s->file)) {
Juan Quintelac369f402012-10-03 20:33:34 +0200599 pending_size = qemu_savevm_state_pending(s->file, max_size);
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100600 trace_migrate_pending(pending_size, max_size);
Juan Quintelab22ff1f2012-10-17 21:06:31 +0200601 if (pending_size && pending_size >= max_size) {
Paolo Bonzinidba433c2013-02-22 17:36:17 +0100602 qemu_savevm_state_iterate(s->file);
Juan Quintelac369f402012-10-03 20:33:34 +0200603 } else {
Kevin Wolf0e1146a2013-07-05 13:54:55 +0200604 int ret;
605
Paolo Bonzini32c835b2013-02-22 17:36:27 +0100606 qemu_mutex_lock_iothread();
Alex Blighbc72ad62013-08-21 16:03:08 +0100607 start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintelac369f402012-10-03 20:33:34 +0200608 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100609 old_vm_running = runstate_is_running();
Kevin Wolf0e1146a2013-07-05 13:54:55 +0200610
611 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
612 if (ret >= 0) {
Matthew Garrett40596832013-11-25 14:42:43 -0500613 qemu_file_set_rate_limit(s->file, INT64_MAX);
Kevin Wolf0e1146a2013-07-05 13:54:55 +0200614 qemu_savevm_state_complete(s->file);
615 }
Paolo Bonzini32c835b2013-02-22 17:36:27 +0100616 qemu_mutex_unlock_iothread();
Kevin Wolf0e1146a2013-07-05 13:54:55 +0200617
618 if (ret < 0) {
Michael R. Hinesd58f5742013-07-22 10:01:56 -0400619 migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR);
Kevin Wolf0e1146a2013-07-05 13:54:55 +0200620 break;
621 }
622
Paolo Bonzini059f8962013-02-22 17:36:32 +0100623 if (!qemu_file_get_error(s->file)) {
Michael R. Hinesd58f5742013-07-22 10:01:56 -0400624 migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_COMPLETED);
Paolo Bonzini059f8962013-02-22 17:36:32 +0100625 break;
626 }
Juan Quintelac369f402012-10-03 20:33:34 +0200627 }
628 }
Paolo Bonzinif4410a52013-02-22 17:36:20 +0100629
Paolo Bonzinifd45ee22013-02-22 17:36:33 +0100630 if (qemu_file_get_error(s->file)) {
Michael R. Hinesd58f5742013-07-22 10:01:56 -0400631 migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR);
Paolo Bonzinifd45ee22013-02-22 17:36:33 +0100632 break;
633 }
Alex Blighbc72ad62013-08-21 16:03:08 +0100634 current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200635 if (current_time >= initial_time + BUFFER_DELAY) {
Paolo Bonzinibe7172e2013-02-22 17:36:43 +0100636 uint64_t transferred_bytes = qemu_ftell(s->file) - initial_bytes;
Michael Roth77417f12013-05-16 16:25:44 -0500637 uint64_t time_spent = current_time - initial_time;
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200638 double bandwidth = transferred_bytes / time_spent;
639 max_size = bandwidth * migrate_max_downtime() / 1000000;
640
Michael R. Hines7e114f82013-06-25 21:35:30 -0400641 s->mbps = time_spent ? (((double) transferred_bytes * 8.0) /
642 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0 : -1;
643
Alexey Kardashevskiy9013dca2014-03-11 10:42:29 +1100644 trace_migrate_transferred(transferred_bytes, time_spent,
645 bandwidth, max_size);
Juan Quintela90f8ae72013-02-01 13:22:37 +0100646 /* if we haven't sent anything, we don't want to recalculate
647 10000 is a small enough number for our purposes */
648 if (s->dirty_bytes_rate && transferred_bytes > 10000) {
649 s->expected_downtime = s->dirty_bytes_rate / bandwidth;
650 }
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200651
Paolo Bonzini1964a392013-02-22 17:36:45 +0100652 qemu_file_reset_rate_limit(s->file);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200653 initial_time = current_time;
Paolo Bonzinibe7172e2013-02-22 17:36:43 +0100654 initial_bytes = qemu_ftell(s->file);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200655 }
Paolo Bonzinia0ff0442013-02-22 17:36:35 +0100656 if (qemu_file_rate_limit(s->file)) {
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200657 /* usleep expects microseconds */
658 g_usleep((initial_time + BUFFER_DELAY - current_time)*1000);
659 }
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100660 }
661
Paolo Bonzinif4410a52013-02-22 17:36:20 +0100662 qemu_mutex_lock_iothread();
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100663 if (s->state == MIG_STATE_COMPLETED) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100664 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Peter Lievend6ed7312014-05-12 10:46:00 +0200665 uint64_t transferred_bytes = qemu_ftell(s->file);
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100666 s->total_time = end_time - s->total_time;
667 s->downtime = end_time - start_time;
Peter Lievend6ed7312014-05-12 10:46:00 +0200668 if (s->total_time) {
669 s->mbps = (((double) transferred_bytes * 8.0) /
670 ((double) s->total_time)) / 1000;
671 }
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100672 runstate_set(RUN_STATE_POSTMIGRATE);
673 } else {
674 if (old_vm_running) {
Paolo Bonzinia3fa1d72013-02-22 17:36:18 +0100675 vm_start();
Paolo Bonzinidba433c2013-02-22 17:36:17 +0100676 }
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200677 }
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100678 qemu_bh_schedule(s->cleanup_bh);
Paolo Bonzinidba433c2013-02-22 17:36:17 +0100679 qemu_mutex_unlock_iothread();
Paolo Bonzinif4410a52013-02-22 17:36:20 +0100680
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200681 return NULL;
682}
683
Juan Quintela9848a402012-12-19 09:55:50 +0100684void migrate_fd_connect(MigrationState *s)
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200685{
Michael R. Hines29ae8a42013-07-22 10:01:57 -0400686 s->state = MIG_STATE_SETUP;
687 trace_migrate_set_state(MIG_STATE_SETUP);
Kazuya Saitoc09e5bb2013-02-22 17:36:19 +0100688
Juan Quintelacc283e32013-02-01 11:12:26 +0100689 /* This is a best 1st approximation. ns to ms */
690 s->expected_downtime = max_downtime/1000000;
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100691 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200692
Paolo Bonzini442773c2013-02-22 17:36:44 +0100693 qemu_file_set_rate_limit(s->file,
694 s->bandwidth_limit / XFER_LIMIT_RATIO);
695
Stefan Hajnoczi9287ac22013-07-29 15:01:57 +0200696 /* Notify before starting migration thread */
697 notifier_list_notify(&migration_state_notifiers, s);
698
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +0000699 qemu_thread_create(&s->thread, "migration", migration_thread, s,
Paolo Bonzinibb1fadc2013-02-22 17:36:21 +0100700 QEMU_THREAD_JOINABLE);
Juan Quintela0d82d0e2012-10-03 14:18:33 +0200701}