target-arm: wire up the softfloat flush_input_to_zero flag
[qemu.git] / migration.c
blobe5ba51c314d8916cd3ed9bcf0caa6059d091cbf9
1 /*
2 * QEMU live migration
4 * Copyright IBM, Corp. 2008
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "qemu-common.h"
15 #include "migration.h"
16 #include "monitor.h"
17 #include "buffered_file.h"
18 #include "sysemu.h"
19 #include "block.h"
20 #include "qemu_socket.h"
21 #include "block-migration.h"
22 #include "qemu-objects.h"
24 //#define DEBUG_MIGRATION
26 #ifdef DEBUG_MIGRATION
27 #define DPRINTF(fmt, ...) \
28 do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
29 #else
30 #define DPRINTF(fmt, ...) \
31 do { } while (0)
32 #endif
34 /* Migration speed throttling */
35 static int64_t max_throttle = (32 << 20);
37 static MigrationState *current_migration;
39 int qemu_start_incoming_migration(const char *uri)
41 const char *p;
42 int ret;
44 if (strstart(uri, "tcp:", &p))
45 ret = tcp_start_incoming_migration(p);
46 #if !defined(WIN32)
47 else if (strstart(uri, "exec:", &p))
48 ret = exec_start_incoming_migration(p);
49 else if (strstart(uri, "unix:", &p))
50 ret = unix_start_incoming_migration(p);
51 else if (strstart(uri, "fd:", &p))
52 ret = fd_start_incoming_migration(p);
53 #endif
54 else {
55 fprintf(stderr, "unknown migration protocol: %s\n", uri);
56 ret = -EPROTONOSUPPORT;
58 return ret;
61 void process_incoming_migration(QEMUFile *f)
63 if (qemu_loadvm_state(f) < 0) {
64 fprintf(stderr, "load of migration failed\n");
65 exit(0);
67 qemu_announce_self();
68 DPRINTF("successfully loaded vm state\n");
70 incoming_expected = false;
72 if (autostart)
73 vm_start();
76 int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)
78 MigrationState *s = NULL;
79 const char *p;
80 int detach = qdict_get_try_bool(qdict, "detach", 0);
81 int blk = qdict_get_try_bool(qdict, "blk", 0);
82 int inc = qdict_get_try_bool(qdict, "inc", 0);
83 const char *uri = qdict_get_str(qdict, "uri");
85 if (current_migration &&
86 current_migration->get_status(current_migration) == MIG_STATE_ACTIVE) {
87 monitor_printf(mon, "migration already in progress\n");
88 return -1;
91 if (strstart(uri, "tcp:", &p)) {
92 s = tcp_start_outgoing_migration(mon, p, max_throttle, detach,
93 blk, inc);
94 #if !defined(WIN32)
95 } else if (strstart(uri, "exec:", &p)) {
96 s = exec_start_outgoing_migration(mon, p, max_throttle, detach,
97 blk, inc);
98 } else if (strstart(uri, "unix:", &p)) {
99 s = unix_start_outgoing_migration(mon, p, max_throttle, detach,
100 blk, inc);
101 } else if (strstart(uri, "fd:", &p)) {
102 s = fd_start_outgoing_migration(mon, p, max_throttle, detach,
103 blk, inc);
104 #endif
105 } else {
106 monitor_printf(mon, "unknown migration protocol: %s\n", uri);
107 return -1;
110 if (s == NULL) {
111 monitor_printf(mon, "migration failed\n");
112 return -1;
115 if (current_migration) {
116 current_migration->release(current_migration);
119 current_migration = s;
120 return 0;
123 int do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)
125 MigrationState *s = current_migration;
127 if (s)
128 s->cancel(s);
130 return 0;
133 int do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)
135 int64_t d;
136 FdMigrationState *s;
138 d = qdict_get_int(qdict, "value");
139 if (d < 0) {
140 d = 0;
142 max_throttle = d;
144 s = migrate_to_fms(current_migration);
145 if (s && s->file) {
146 qemu_file_set_rate_limit(s->file, max_throttle);
149 return 0;
152 /* amount of nanoseconds we are willing to wait for migration to be down.
153 * the choice of nanoseconds is because it is the maximum resolution that
154 * get_clock() can achieve. It is an internal measure. All user-visible
155 * units must be in seconds */
156 static uint64_t max_downtime = 30000000;
158 uint64_t migrate_max_downtime(void)
160 return max_downtime;
163 int do_migrate_set_downtime(Monitor *mon, const QDict *qdict,
164 QObject **ret_data)
166 double d;
168 d = qdict_get_double(qdict, "value") * 1e9;
169 d = MAX(0, MIN(UINT64_MAX, d));
170 max_downtime = (uint64_t)d;
172 return 0;
175 static void migrate_print_status(Monitor *mon, const char *name,
176 const QDict *status_dict)
178 QDict *qdict;
180 qdict = qobject_to_qdict(qdict_get(status_dict, name));
182 monitor_printf(mon, "transferred %s: %" PRIu64 " kbytes\n", name,
183 qdict_get_int(qdict, "transferred") >> 10);
184 monitor_printf(mon, "remaining %s: %" PRIu64 " kbytes\n", name,
185 qdict_get_int(qdict, "remaining") >> 10);
186 monitor_printf(mon, "total %s: %" PRIu64 " kbytes\n", name,
187 qdict_get_int(qdict, "total") >> 10);
190 void do_info_migrate_print(Monitor *mon, const QObject *data)
192 QDict *qdict;
194 qdict = qobject_to_qdict(data);
196 monitor_printf(mon, "Migration status: %s\n",
197 qdict_get_str(qdict, "status"));
199 if (qdict_haskey(qdict, "ram")) {
200 migrate_print_status(mon, "ram", qdict);
203 if (qdict_haskey(qdict, "disk")) {
204 migrate_print_status(mon, "disk", qdict);
208 static void migrate_put_status(QDict *qdict, const char *name,
209 uint64_t trans, uint64_t rem, uint64_t total)
211 QObject *obj;
213 obj = qobject_from_jsonf("{ 'transferred': %" PRId64 ", "
214 "'remaining': %" PRId64 ", "
215 "'total': %" PRId64 " }", trans, rem, total);
216 qdict_put_obj(qdict, name, obj);
219 void do_info_migrate(Monitor *mon, QObject **ret_data)
221 QDict *qdict;
222 MigrationState *s = current_migration;
224 if (s) {
225 switch (s->get_status(s)) {
226 case MIG_STATE_ACTIVE:
227 qdict = qdict_new();
228 qdict_put(qdict, "status", qstring_from_str("active"));
230 migrate_put_status(qdict, "ram", ram_bytes_transferred(),
231 ram_bytes_remaining(), ram_bytes_total());
233 if (blk_mig_active()) {
234 migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(),
235 blk_mig_bytes_remaining(),
236 blk_mig_bytes_total());
239 *ret_data = QOBJECT(qdict);
240 break;
241 case MIG_STATE_COMPLETED:
242 *ret_data = qobject_from_jsonf("{ 'status': 'completed' }");
243 break;
244 case MIG_STATE_ERROR:
245 *ret_data = qobject_from_jsonf("{ 'status': 'failed' }");
246 break;
247 case MIG_STATE_CANCELLED:
248 *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");
249 break;
254 /* shared migration helpers */
256 void migrate_fd_monitor_suspend(FdMigrationState *s, Monitor *mon)
258 s->mon = mon;
259 if (monitor_suspend(mon) == 0) {
260 DPRINTF("suspending monitor\n");
261 } else {
262 monitor_printf(mon, "terminal does not allow synchronous "
263 "migration, continuing detached\n");
267 void migrate_fd_error(FdMigrationState *s)
269 DPRINTF("setting error state\n");
270 s->state = MIG_STATE_ERROR;
271 migrate_fd_cleanup(s);
274 int migrate_fd_cleanup(FdMigrationState *s)
276 int ret = 0;
278 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
280 if (s->file) {
281 DPRINTF("closing file\n");
282 if (qemu_fclose(s->file) != 0) {
283 ret = -1;
285 s->file = NULL;
288 if (s->fd != -1)
289 close(s->fd);
291 /* Don't resume monitor until we've flushed all of the buffers */
292 if (s->mon) {
293 monitor_resume(s->mon);
296 s->fd = -1;
298 return ret;
301 void migrate_fd_put_notify(void *opaque)
303 FdMigrationState *s = opaque;
305 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
306 qemu_file_put_notify(s->file);
309 ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
311 FdMigrationState *s = opaque;
312 ssize_t ret;
314 do {
315 ret = s->write(s, data, size);
316 } while (ret == -1 && ((s->get_error(s)) == EINTR));
318 if (ret == -1)
319 ret = -(s->get_error(s));
321 if (ret == -EAGAIN) {
322 qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);
323 } else if (ret < 0) {
324 if (s->mon) {
325 monitor_resume(s->mon);
327 s->state = MIG_STATE_ERROR;
330 return ret;
333 void migrate_fd_connect(FdMigrationState *s)
335 int ret;
337 s->file = qemu_fopen_ops_buffered(s,
338 s->bandwidth_limit,
339 migrate_fd_put_buffer,
340 migrate_fd_put_ready,
341 migrate_fd_wait_for_unfreeze,
342 migrate_fd_close);
344 DPRINTF("beginning savevm\n");
345 ret = qemu_savevm_state_begin(s->mon, s->file, s->mig_state.blk,
346 s->mig_state.shared);
347 if (ret < 0) {
348 DPRINTF("failed, %d\n", ret);
349 migrate_fd_error(s);
350 return;
353 migrate_fd_put_ready(s);
356 void migrate_fd_put_ready(void *opaque)
358 FdMigrationState *s = opaque;
360 if (s->state != MIG_STATE_ACTIVE) {
361 DPRINTF("put_ready returning because of non-active state\n");
362 return;
365 DPRINTF("iterate\n");
366 if (qemu_savevm_state_iterate(s->mon, s->file) == 1) {
367 int state;
368 int old_vm_running = vm_running;
370 DPRINTF("done iterating\n");
371 vm_stop(0);
373 if ((qemu_savevm_state_complete(s->mon, s->file)) < 0) {
374 if (old_vm_running) {
375 vm_start();
377 state = MIG_STATE_ERROR;
378 } else {
379 state = MIG_STATE_COMPLETED;
381 if (migrate_fd_cleanup(s) < 0) {
382 if (old_vm_running) {
383 vm_start();
385 state = MIG_STATE_ERROR;
387 s->state = state;
391 int migrate_fd_get_status(MigrationState *mig_state)
393 FdMigrationState *s = migrate_to_fms(mig_state);
394 return s->state;
397 void migrate_fd_cancel(MigrationState *mig_state)
399 FdMigrationState *s = migrate_to_fms(mig_state);
401 if (s->state != MIG_STATE_ACTIVE)
402 return;
404 DPRINTF("cancelling migration\n");
406 s->state = MIG_STATE_CANCELLED;
407 qemu_savevm_state_cancel(s->mon, s->file);
409 migrate_fd_cleanup(s);
412 void migrate_fd_release(MigrationState *mig_state)
414 FdMigrationState *s = migrate_to_fms(mig_state);
416 DPRINTF("releasing state\n");
418 if (s->state == MIG_STATE_ACTIVE) {
419 s->state = MIG_STATE_CANCELLED;
420 migrate_fd_cleanup(s);
422 qemu_free(s);
425 void migrate_fd_wait_for_unfreeze(void *opaque)
427 FdMigrationState *s = opaque;
428 int ret;
430 DPRINTF("wait for unfreeze\n");
431 if (s->state != MIG_STATE_ACTIVE)
432 return;
434 do {
435 fd_set wfds;
437 FD_ZERO(&wfds);
438 FD_SET(s->fd, &wfds);
440 ret = select(s->fd + 1, NULL, &wfds, NULL, NULL);
441 } while (ret == -1 && (s->get_error(s)) == EINTR);
444 int migrate_fd_close(void *opaque)
446 FdMigrationState *s = opaque;
448 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
449 return s->close(s);