4 * Copyright IBM, Corp. 2008
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"
17 #include "buffered_file.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)
30 #define dprintf(fmt, ...) \
34 /* Migration speed throttling */
35 static uint32_t max_throttle
= (32 << 20);
37 static MigrationState
*current_migration
;
39 void qemu_start_incoming_migration(const char *uri
)
43 if (strstart(uri
, "tcp:", &p
))
44 tcp_start_incoming_migration(p
);
46 else if (strstart(uri
, "exec:", &p
))
47 exec_start_incoming_migration(p
);
48 else if (strstart(uri
, "unix:", &p
))
49 unix_start_incoming_migration(p
);
50 else if (strstart(uri
, "fd:", &p
))
51 fd_start_incoming_migration(p
);
54 fprintf(stderr
, "unknown migration protocol: %s\n", uri
);
57 void do_migrate(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
59 MigrationState
*s
= NULL
;
61 int detach
= qdict_get_int(qdict
, "detach");
62 const char *uri
= qdict_get_str(qdict
, "uri");
64 if (current_migration
&&
65 current_migration
->get_status(current_migration
) == MIG_STATE_ACTIVE
) {
66 monitor_printf(mon
, "migration already in progress\n");
70 if (strstart(uri
, "tcp:", &p
))
71 s
= tcp_start_outgoing_migration(mon
, p
, max_throttle
, detach
,
72 (int)qdict_get_int(qdict
, "blk"),
73 (int)qdict_get_int(qdict
, "inc"));
75 else if (strstart(uri
, "exec:", &p
))
76 s
= exec_start_outgoing_migration(mon
, p
, max_throttle
, detach
,
77 (int)qdict_get_int(qdict
, "blk"),
78 (int)qdict_get_int(qdict
, "inc"));
79 else if (strstart(uri
, "unix:", &p
))
80 s
= unix_start_outgoing_migration(mon
, p
, max_throttle
, detach
,
81 (int)qdict_get_int(qdict
, "blk"),
82 (int)qdict_get_int(qdict
, "inc"));
83 else if (strstart(uri
, "fd:", &p
))
84 s
= fd_start_outgoing_migration(mon
, p
, max_throttle
, detach
,
85 (int)qdict_get_int(qdict
, "blk"),
86 (int)qdict_get_int(qdict
, "inc"));
89 monitor_printf(mon
, "unknown migration protocol: %s\n", uri
);
92 monitor_printf(mon
, "migration failed\n");
94 if (current_migration
)
95 current_migration
->release(current_migration
);
97 current_migration
= s
;
101 void do_migrate_cancel(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
103 MigrationState
*s
= current_migration
;
109 void do_migrate_set_speed(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
114 d
= qdict_get_double(qdict
, "value");
115 d
= MAX(0, MIN(UINT32_MAX
, d
));
118 s
= migrate_to_fms(current_migration
);
120 qemu_file_set_rate_limit(s
->file
, max_throttle
);
124 /* amount of nanoseconds we are willing to wait for migration to be down.
125 * the choice of nanoseconds is because it is the maximum resolution that
126 * get_clock() can achieve. It is an internal measure. All user-visible
127 * units must be in seconds */
128 static uint64_t max_downtime
= 30000000;
130 uint64_t migrate_max_downtime(void)
135 void do_migrate_set_downtime(Monitor
*mon
, const QDict
*qdict
)
139 d
= qdict_get_double(qdict
, "value") * 1e9
;
140 d
= MAX(0, MIN(UINT64_MAX
, d
));
141 max_downtime
= (uint64_t)d
;
144 static void migrate_print_status(Monitor
*mon
, const char *name
,
145 const QDict
*status_dict
)
149 qdict
= qobject_to_qdict(qdict_get(status_dict
, name
));
151 monitor_printf(mon
, "transferred %s: %" PRIu64
" kbytes\n", name
,
152 qdict_get_int(qdict
, "transferred") >> 10);
153 monitor_printf(mon
, "remaining %s: %" PRIu64
" kbytes\n", name
,
154 qdict_get_int(qdict
, "remaining") >> 10);
155 monitor_printf(mon
, "total %s: %" PRIu64
" kbytes\n", name
,
156 qdict_get_int(qdict
, "total") >> 10);
159 void do_info_migrate_print(Monitor
*mon
, const QObject
*data
)
163 qdict
= qobject_to_qdict(data
);
165 monitor_printf(mon
, "Migration status: %s\n",
166 qdict_get_str(qdict
, "status"));
168 if (qdict_haskey(qdict
, "ram")) {
169 migrate_print_status(mon
, "ram", qdict
);
172 if (qdict_haskey(qdict
, "disk")) {
173 migrate_print_status(mon
, "disk", qdict
);
177 static void migrate_put_status(QDict
*qdict
, const char *name
,
178 uint64_t trans
, uint64_t rem
, uint64_t total
)
182 obj
= qobject_from_jsonf("{ 'transferred': %" PRId64
", "
183 "'remaining': %" PRId64
", "
184 "'total': %" PRId64
" }", trans
, rem
, total
);
187 qdict_put_obj(qdict
, name
, obj
);
191 * do_info_migrate(): Migration status
193 * Return a QDict. If migration is active there will be another
194 * QDict with RAM migration status and if block migration is active
195 * another one with block migration status.
197 * The main QDict contains the following:
199 * - "status": migration status
200 * - "ram": only present if "status" is "active", it is a QDict with the
201 * following RAM information (in bytes):
202 * - "transferred": amount transferred
203 * - "remaining": amount remaining
205 * - "disk": only present if "status" is "active" and it is a block migration,
206 * it is a QDict with the following disk information (in bytes):
207 * - "transferred": amount transferred
208 * - "remaining": amount remaining
213 * 1. Migration is "completed":
215 * { "status": "completed" }
217 * 2. Migration is "active" and it is not a block migration:
219 * { "status": "active",
220 * "ram": { "transferred": 123, "remaining": 123, "total": 246 } }
222 * 3. Migration is "active" and it is a block migration:
224 * { "status": "active",
225 * "ram": { "total": 1057024, "remaining": 1053304, "transferred": 3720 },
226 * "disk": { "total": 20971520, "remaining": 20880384, "transferred": 91136 }}
228 void do_info_migrate(Monitor
*mon
, QObject
**ret_data
)
231 MigrationState
*s
= current_migration
;
234 switch (s
->get_status(s
)) {
235 case MIG_STATE_ACTIVE
:
237 qdict_put(qdict
, "status", qstring_from_str("active"));
239 migrate_put_status(qdict
, "ram", ram_bytes_transferred(),
240 ram_bytes_remaining(), ram_bytes_total());
242 if (blk_mig_active()) {
243 migrate_put_status(qdict
, "disk", blk_mig_bytes_transferred(),
244 blk_mig_bytes_remaining(),
245 blk_mig_bytes_total());
248 *ret_data
= QOBJECT(qdict
);
250 case MIG_STATE_COMPLETED
:
251 *ret_data
= qobject_from_jsonf("{ 'status': 'completed' }");
253 case MIG_STATE_ERROR
:
254 *ret_data
= qobject_from_jsonf("{ 'status': 'failed' }");
256 case MIG_STATE_CANCELLED
:
257 *ret_data
= qobject_from_jsonf("{ 'status': 'cancelled' }");
260 assert(*ret_data
!= NULL
);
264 /* shared migration helpers */
266 void migrate_fd_monitor_suspend(FdMigrationState
*s
, Monitor
*mon
)
269 if (monitor_suspend(mon
) == 0) {
270 dprintf("suspending monitor\n");
272 monitor_printf(mon
, "terminal does not allow synchronous "
273 "migration, continuing detached\n");
277 void migrate_fd_error(FdMigrationState
*s
)
279 dprintf("setting error state\n");
280 s
->state
= MIG_STATE_ERROR
;
281 migrate_fd_cleanup(s
);
284 void migrate_fd_cleanup(FdMigrationState
*s
)
286 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
289 dprintf("closing file\n");
290 qemu_fclose(s
->file
);
297 /* Don't resume monitor until we've flushed all of the buffers */
299 monitor_resume(s
->mon
);
305 void migrate_fd_put_notify(void *opaque
)
307 FdMigrationState
*s
= opaque
;
309 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
310 qemu_file_put_notify(s
->file
);
313 ssize_t
migrate_fd_put_buffer(void *opaque
, const void *data
, size_t size
)
315 FdMigrationState
*s
= opaque
;
319 ret
= s
->write(s
, data
, size
);
320 } while (ret
== -1 && ((s
->get_error(s
)) == EINTR
));
323 ret
= -(s
->get_error(s
));
326 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, migrate_fd_put_notify
, s
);
331 void migrate_fd_connect(FdMigrationState
*s
)
335 s
->file
= qemu_fopen_ops_buffered(s
,
337 migrate_fd_put_buffer
,
338 migrate_fd_put_ready
,
339 migrate_fd_wait_for_unfreeze
,
342 dprintf("beginning savevm\n");
343 ret
= qemu_savevm_state_begin(s
->mon
, s
->file
, s
->mig_state
.blk
,
344 s
->mig_state
.shared
);
346 dprintf("failed, %d\n", ret
);
351 migrate_fd_put_ready(s
);
354 void migrate_fd_put_ready(void *opaque
)
356 FdMigrationState
*s
= opaque
;
358 if (s
->state
!= MIG_STATE_ACTIVE
) {
359 dprintf("put_ready returning because of non-active state\n");
363 dprintf("iterate\n");
364 if (qemu_savevm_state_iterate(s
->mon
, s
->file
) == 1) {
366 int old_vm_running
= vm_running
;
368 dprintf("done iterating\n");
373 if ((qemu_savevm_state_complete(s
->mon
, s
->file
)) < 0) {
374 if (old_vm_running
) {
377 state
= MIG_STATE_ERROR
;
379 state
= MIG_STATE_COMPLETED
;
381 migrate_fd_cleanup(s
);
386 int migrate_fd_get_status(MigrationState
*mig_state
)
388 FdMigrationState
*s
= migrate_to_fms(mig_state
);
392 void migrate_fd_cancel(MigrationState
*mig_state
)
394 FdMigrationState
*s
= migrate_to_fms(mig_state
);
396 if (s
->state
!= MIG_STATE_ACTIVE
)
399 dprintf("cancelling migration\n");
401 s
->state
= MIG_STATE_CANCELLED
;
402 qemu_savevm_state_cancel(s
->mon
, s
->file
);
404 migrate_fd_cleanup(s
);
407 void migrate_fd_release(MigrationState
*mig_state
)
409 FdMigrationState
*s
= migrate_to_fms(mig_state
);
411 dprintf("releasing state\n");
413 if (s
->state
== MIG_STATE_ACTIVE
) {
414 s
->state
= MIG_STATE_CANCELLED
;
415 migrate_fd_cleanup(s
);
420 void migrate_fd_wait_for_unfreeze(void *opaque
)
422 FdMigrationState
*s
= opaque
;
425 dprintf("wait for unfreeze\n");
426 if (s
->state
!= MIG_STATE_ACTIVE
)
433 FD_SET(s
->fd
, &wfds
);
435 ret
= select(s
->fd
+ 1, NULL
, &wfds
, NULL
, NULL
);
436 } while (ret
== -1 && (s
->get_error(s
)) == EINTR
);
439 int migrate_fd_close(void *opaque
)
441 FdMigrationState
*s
= opaque
;
443 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);