blob: f2499cfdd485d3268ec6b80225571b942db6f306 [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 *
12 */
13
14#include "qemu-common.h"
15#include "migration.h"
aliguori376253e2009-03-05 23:01:23 +000016#include "monitor.h"
aliguori065e2812008-11-11 16:46:33 +000017#include "buffered_file.h"
18#include "sysemu.h"
19#include "block.h"
20#include "qemu_socket.h"
Jan Kiszka25f23642009-11-30 18:21:21 +010021#include "block-migration.h"
Luiz Capitulinoc86a6682009-12-10 17:16:05 -020022#include "qemu-objects.h"
aliguori065e2812008-11-11 16:46:33 +000023
24//#define DEBUG_MIGRATION
25
26#ifdef DEBUG_MIGRATION
malcd0f2c4c2010-02-07 02:03:50 +030027#define DPRINTF(fmt, ...) \
aliguori065e2812008-11-11 16:46:33 +000028 do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
29#else
malcd0f2c4c2010-02-07 02:03:50 +030030#define DPRINTF(fmt, ...) \
aliguori065e2812008-11-11 16:46:33 +000031 do { } while (0)
32#endif
aliguori5bb79102008-10-13 03:12:02 +000033
34/* Migration speed throttling */
Michael S. Tsirkin3d002df2010-11-23 19:05:54 +020035static int64_t max_throttle = (32 << 20);
aliguori5bb79102008-10-13 03:12:02 +000036
37static MigrationState *current_migration;
38
Gerd Hoffmann99a0db92010-12-13 17:30:12 +010039static NotifierList migration_state_notifiers =
40 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
41
Juan Quintela8ca5e802010-06-09 14:10:54 +020042int qemu_start_incoming_migration(const char *uri)
aliguori5bb79102008-10-13 03:12:02 +000043{
aliguori34c9dd82008-10-13 03:14:31 +000044 const char *p;
Juan Quintela8ca5e802010-06-09 14:10:54 +020045 int ret;
aliguori34c9dd82008-10-13 03:14:31 +000046
47 if (strstart(uri, "tcp:", &p))
Juan Quintela8ca5e802010-06-09 14:10:54 +020048 ret = tcp_start_incoming_migration(p);
aliguori065e2812008-11-11 16:46:33 +000049#if !defined(WIN32)
50 else if (strstart(uri, "exec:", &p))
Juan Quintela8ca5e802010-06-09 14:10:54 +020051 ret = exec_start_incoming_migration(p);
Chris Lalancette4951f652009-08-05 17:24:29 +020052 else if (strstart(uri, "unix:", &p))
Juan Quintela8ca5e802010-06-09 14:10:54 +020053 ret = unix_start_incoming_migration(p);
Paolo Bonzini5ac1fad2009-08-18 15:56:25 +020054 else if (strstart(uri, "fd:", &p))
Juan Quintela8ca5e802010-06-09 14:10:54 +020055 ret = fd_start_incoming_migration(p);
aliguori065e2812008-11-11 16:46:33 +000056#endif
Juan Quintela8ca5e802010-06-09 14:10:54 +020057 else {
aliguori34c9dd82008-10-13 03:14:31 +000058 fprintf(stderr, "unknown migration protocol: %s\n", uri);
Juan Quintela8ca5e802010-06-09 14:10:54 +020059 ret = -EPROTONOSUPPORT;
60 }
61 return ret;
aliguori5bb79102008-10-13 03:12:02 +000062}
63
Juan Quintela511c0232010-06-09 14:10:55 +020064void process_incoming_migration(QEMUFile *f)
65{
66 if (qemu_loadvm_state(f) < 0) {
67 fprintf(stderr, "load of migration failed\n");
68 exit(0);
69 }
70 qemu_announce_self();
71 DPRINTF("successfully loaded vm state\n");
72
Amit Shah8e848652010-07-27 15:49:19 +053073 incoming_expected = false;
74
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -030075 if (autostart) {
Juan Quintela511c0232010-06-09 14:10:55 +020076 vm_start();
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -030077 } else {
78 runstate_set(RSTATE_PRE_LAUNCH);
79 }
Juan Quintela511c0232010-06-09 14:10:55 +020080}
81
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -020082int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori5bb79102008-10-13 03:12:02 +000083{
aliguori34c9dd82008-10-13 03:14:31 +000084 MigrationState *s = NULL;
85 const char *p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -030086 int detach = qdict_get_try_bool(qdict, "detach", 0);
87 int blk = qdict_get_try_bool(qdict, "blk", 0);
88 int inc = qdict_get_try_bool(qdict, "inc", 0);
Luiz Capitulinof18c16d2009-08-28 15:27:14 -030089 const char *uri = qdict_get_str(qdict, "uri");
Jan Kiszka13024252009-11-30 18:21:19 +010090
91 if (current_migration &&
92 current_migration->get_status(current_migration) == MIG_STATE_ACTIVE) {
93 monitor_printf(mon, "migration already in progress\n");
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -020094 return -1;
Jan Kiszka13024252009-11-30 18:21:19 +010095 }
96
Alex Williamsondc912122011-01-11 14:39:43 -070097 if (qemu_savevm_state_blocked(mon)) {
98 return -1;
99 }
100
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200101 if (strstart(uri, "tcp:", &p)) {
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100102 s = tcp_start_outgoing_migration(mon, p, max_throttle, detach,
Luiz Capitulinoeb159d12010-05-28 15:25:24 -0300103 blk, inc);
aliguori065e2812008-11-11 16:46:33 +0000104#if !defined(WIN32)
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200105 } else if (strstart(uri, "exec:", &p)) {
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100106 s = exec_start_outgoing_migration(mon, p, max_throttle, detach,
Luiz Capitulinoeb159d12010-05-28 15:25:24 -0300107 blk, inc);
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200108 } else if (strstart(uri, "unix:", &p)) {
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100109 s = unix_start_outgoing_migration(mon, p, max_throttle, detach,
Luiz Capitulinoeb159d12010-05-28 15:25:24 -0300110 blk, inc);
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200111 } else if (strstart(uri, "fd:", &p)) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200112 s = fd_start_outgoing_migration(mon, p, max_throttle, detach,
Luiz Capitulinoeb159d12010-05-28 15:25:24 -0300113 blk, inc);
aliguori065e2812008-11-11 16:46:33 +0000114#endif
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200115 } else {
aliguori376253e2009-03-05 23:01:23 +0000116 monitor_printf(mon, "unknown migration protocol: %s\n", uri);
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200117 return -1;
aliguori34c9dd82008-10-13 03:14:31 +0000118 }
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200119
120 if (s == NULL) {
121 monitor_printf(mon, "migration failed\n");
122 return -1;
123 }
124
125 if (current_migration) {
126 current_migration->release(current_migration);
127 }
128
129 current_migration = s;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200130 notifier_list_notify(&migration_state_notifiers, NULL);
Luiz Capitulinob5d17ad2010-02-10 23:49:57 -0200131 return 0;
aliguori5bb79102008-10-13 03:12:02 +0000132}
133
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200134int do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori5bb79102008-10-13 03:12:02 +0000135{
136 MigrationState *s = current_migration;
137
138 if (s)
aliguoriff8d81d2008-10-24 22:10:31 +0000139 s->cancel(s);
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200140
141 return 0;
aliguori5bb79102008-10-13 03:12:02 +0000142}
143
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200144int do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori5bb79102008-10-13 03:12:02 +0000145{
Jes Sorensened3d4a82010-10-21 17:15:48 +0200146 int64_t d;
Glauber Costadaa91de2009-05-20 18:26:58 -0400147 FdMigrationState *s;
aliguori5bb79102008-10-13 03:12:02 +0000148
Jes Sorensened3d4a82010-10-21 17:15:48 +0200149 d = qdict_get_int(qdict, "value");
Michael S. Tsirkin3d002df2010-11-23 19:05:54 +0200150 if (d < 0) {
151 d = 0;
152 }
Markus Armbruster5667c492010-01-25 14:23:04 +0100153 max_throttle = d;
Glauber Costadaa91de2009-05-20 18:26:58 -0400154
Jan Kiszka5d39c792009-11-30 18:21:19 +0100155 s = migrate_to_fms(current_migration);
156 if (s && s->file) {
Glauber Costadaa91de2009-05-20 18:26:58 -0400157 qemu_file_set_rate_limit(s->file, max_throttle);
158 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200159
160 return 0;
aliguori5bb79102008-10-13 03:12:02 +0000161}
162
Glauber Costaa0a3fd62009-05-28 15:22:57 -0400163/* amount of nanoseconds we are willing to wait for migration to be down.
164 * the choice of nanoseconds is because it is the maximum resolution that
165 * get_clock() can achieve. It is an internal measure. All user-visible
166 * units must be in seconds */
167static uint64_t max_downtime = 30000000;
168
169uint64_t migrate_max_downtime(void)
170{
171 return max_downtime;
172}
173
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200174int do_migrate_set_downtime(Monitor *mon, const QDict *qdict,
175 QObject **ret_data)
Glauber Costa2ea42952009-05-28 15:22:58 -0400176{
Glauber Costa2ea42952009-05-28 15:22:58 -0400177 double d;
178
Markus Armbrusterb0fbf7d2010-01-25 14:23:07 +0100179 d = qdict_get_double(qdict, "value") * 1e9;
180 d = MAX(0, MIN(UINT64_MAX, d));
Glauber Costa2ea42952009-05-28 15:22:58 -0400181 max_downtime = (uint64_t)d;
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200182
183 return 0;
Glauber Costa2ea42952009-05-28 15:22:58 -0400184}
185
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200186static void migrate_print_status(Monitor *mon, const char *name,
187 const QDict *status_dict)
aliguori5bb79102008-10-13 03:12:02 +0000188{
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200189 QDict *qdict;
190
191 qdict = qobject_to_qdict(qdict_get(status_dict, name));
192
193 monitor_printf(mon, "transferred %s: %" PRIu64 " kbytes\n", name,
194 qdict_get_int(qdict, "transferred") >> 10);
195 monitor_printf(mon, "remaining %s: %" PRIu64 " kbytes\n", name,
196 qdict_get_int(qdict, "remaining") >> 10);
197 monitor_printf(mon, "total %s: %" PRIu64 " kbytes\n", name,
198 qdict_get_int(qdict, "total") >> 10);
199}
200
201void do_info_migrate_print(Monitor *mon, const QObject *data)
202{
203 QDict *qdict;
204
205 qdict = qobject_to_qdict(data);
206
207 monitor_printf(mon, "Migration status: %s\n",
208 qdict_get_str(qdict, "status"));
209
210 if (qdict_haskey(qdict, "ram")) {
211 migrate_print_status(mon, "ram", qdict);
212 }
213
214 if (qdict_haskey(qdict, "disk")) {
215 migrate_print_status(mon, "disk", qdict);
216 }
217}
218
219static void migrate_put_status(QDict *qdict, const char *name,
220 uint64_t trans, uint64_t rem, uint64_t total)
221{
222 QObject *obj;
223
224 obj = qobject_from_jsonf("{ 'transferred': %" PRId64 ", "
225 "'remaining': %" PRId64 ", "
226 "'total': %" PRId64 " }", trans, rem, total);
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200227 qdict_put_obj(qdict, name, obj);
228}
229
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200230void do_info_migrate(Monitor *mon, QObject **ret_data)
231{
232 QDict *qdict;
aliguori5bb79102008-10-13 03:12:02 +0000233 MigrationState *s = current_migration;
aliguori376253e2009-03-05 23:01:23 +0000234
aliguori5bb79102008-10-13 03:12:02 +0000235 if (s) {
aliguoriff8d81d2008-10-24 22:10:31 +0000236 switch (s->get_status(s)) {
237 case MIG_STATE_ACTIVE:
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200238 qdict = qdict_new();
239 qdict_put(qdict, "status", qstring_from_str("active"));
240
241 migrate_put_status(qdict, "ram", ram_bytes_transferred(),
242 ram_bytes_remaining(), ram_bytes_total());
243
Jan Kiszka25f23642009-11-30 18:21:21 +0100244 if (blk_mig_active()) {
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200245 migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(),
246 blk_mig_bytes_remaining(),
247 blk_mig_bytes_total());
Jan Kiszka25f23642009-11-30 18:21:21 +0100248 }
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200249
250 *ret_data = QOBJECT(qdict);
aliguoriff8d81d2008-10-24 22:10:31 +0000251 break;
252 case MIG_STATE_COMPLETED:
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200253 *ret_data = qobject_from_jsonf("{ 'status': 'completed' }");
aliguoriff8d81d2008-10-24 22:10:31 +0000254 break;
255 case MIG_STATE_ERROR:
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200256 *ret_data = qobject_from_jsonf("{ 'status': 'failed' }");
aliguoriff8d81d2008-10-24 22:10:31 +0000257 break;
258 case MIG_STATE_CANCELLED:
Luiz Capitulinoc86a6682009-12-10 17:16:05 -0200259 *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");
aliguoriff8d81d2008-10-24 22:10:31 +0000260 break;
261 }
aliguori5bb79102008-10-13 03:12:02 +0000262 }
263}
264
aliguori065e2812008-11-11 16:46:33 +0000265/* shared migration helpers */
266
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100267void migrate_fd_monitor_suspend(FdMigrationState *s, Monitor *mon)
aliguori731b0362009-03-05 23:01:42 +0000268{
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100269 s->mon = mon;
270 if (monitor_suspend(mon) == 0) {
malcd0f2c4c2010-02-07 02:03:50 +0300271 DPRINTF("suspending monitor\n");
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100272 } else {
273 monitor_printf(mon, "terminal does not allow synchronous "
aliguoricde76ee2009-03-05 23:01:51 +0000274 "migration, continuing detached\n");
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100275 }
aliguori731b0362009-03-05 23:01:42 +0000276}
277
aliguori065e2812008-11-11 16:46:33 +0000278void migrate_fd_error(FdMigrationState *s)
279{
malcd0f2c4c2010-02-07 02:03:50 +0300280 DPRINTF("setting error state\n");
aliguori065e2812008-11-11 16:46:33 +0000281 s->state = MIG_STATE_ERROR;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200282 notifier_list_notify(&migration_state_notifiers, NULL);
aliguori065e2812008-11-11 16:46:33 +0000283 migrate_fd_cleanup(s);
284}
285
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500286int migrate_fd_cleanup(FdMigrationState *s)
aliguori065e2812008-11-11 16:46:33 +0000287{
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500288 int ret = 0;
289
aliguori065e2812008-11-11 16:46:33 +0000290 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
291
292 if (s->file) {
malcd0f2c4c2010-02-07 02:03:50 +0300293 DPRINTF("closing file\n");
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500294 if (qemu_fclose(s->file) != 0) {
295 ret = -1;
296 }
Jan Kiszka5d39c792009-11-30 18:21:19 +0100297 s->file = NULL;
Jan Kiszka84ec6552011-08-05 09:11:26 +0200298 } else {
299 if (s->mon) {
300 monitor_resume(s->mon);
301 }
aliguori065e2812008-11-11 16:46:33 +0000302 }
303
Jan Kiszka84ec6552011-08-05 09:11:26 +0200304 if (s->fd != -1) {
aliguori065e2812008-11-11 16:46:33 +0000305 close(s->fd);
Jan Kiszka84ec6552011-08-05 09:11:26 +0200306 s->fd = -1;
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100307 }
aliguori065e2812008-11-11 16:46:33 +0000308
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500309 return ret;
aliguori065e2812008-11-11 16:46:33 +0000310}
311
312void migrate_fd_put_notify(void *opaque)
313{
314 FdMigrationState *s = opaque;
315
316 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
317 qemu_file_put_notify(s->file);
318}
319
320ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
321{
322 FdMigrationState *s = opaque;
323 ssize_t ret;
324
325 do {
326 ret = s->write(s, data, size);
Uri Lublin95b134e2009-05-19 14:08:53 +0300327 } while (ret == -1 && ((s->get_error(s)) == EINTR));
aliguori065e2812008-11-11 16:46:33 +0000328
329 if (ret == -1)
330 ret = -(s->get_error(s));
331
Marcelo Tosattie447b1a2010-08-19 10:18:39 -0300332 if (ret == -EAGAIN) {
aliguori065e2812008-11-11 16:46:33 +0000333 qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);
Marcelo Tosattie447b1a2010-08-19 10:18:39 -0300334 } else if (ret < 0) {
Marcelo Tosattie447b1a2010-08-19 10:18:39 -0300335 s->state = MIG_STATE_ERROR;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200336 notifier_list_notify(&migration_state_notifiers, NULL);
Marcelo Tosattie447b1a2010-08-19 10:18:39 -0300337 }
aliguori065e2812008-11-11 16:46:33 +0000338
339 return ret;
340}
341
342void migrate_fd_connect(FdMigrationState *s)
343{
344 int ret;
345
346 s->file = qemu_fopen_ops_buffered(s,
347 s->bandwidth_limit,
348 migrate_fd_put_buffer,
349 migrate_fd_put_ready,
350 migrate_fd_wait_for_unfreeze,
351 migrate_fd_close);
352
malcd0f2c4c2010-02-07 02:03:50 +0300353 DPRINTF("beginning savevm\n");
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100354 ret = qemu_savevm_state_begin(s->mon, s->file, s->mig_state.blk,
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200355 s->mig_state.shared);
aliguori065e2812008-11-11 16:46:33 +0000356 if (ret < 0) {
malcd0f2c4c2010-02-07 02:03:50 +0300357 DPRINTF("failed, %d\n", ret);
aliguori065e2812008-11-11 16:46:33 +0000358 migrate_fd_error(s);
359 return;
360 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200361
aliguori065e2812008-11-11 16:46:33 +0000362 migrate_fd_put_ready(s);
363}
364
365void migrate_fd_put_ready(void *opaque)
366{
367 FdMigrationState *s = opaque;
368
369 if (s->state != MIG_STATE_ACTIVE) {
malcd0f2c4c2010-02-07 02:03:50 +0300370 DPRINTF("put_ready returning because of non-active state\n");
aliguori065e2812008-11-11 16:46:33 +0000371 return;
372 }
373
malcd0f2c4c2010-02-07 02:03:50 +0300374 DPRINTF("iterate\n");
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100375 if (qemu_savevm_state_iterate(s->mon, s->file) == 1) {
aliguorib161d122009-04-05 19:30:33 +0000376 int state;
Anthony Liguorieeb34af2009-07-09 13:25:47 -0500377 int old_vm_running = vm_running;
378
malcd0f2c4c2010-02-07 02:03:50 +0300379 DPRINTF("done iterating\n");
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -0300380 vm_stop(RSTATE_PRE_MIGRATE);
aliguori065e2812008-11-11 16:46:33 +0000381
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100382 if ((qemu_savevm_state_complete(s->mon, s->file)) < 0) {
Anthony Liguorieeb34af2009-07-09 13:25:47 -0500383 if (old_vm_running) {
384 vm_start();
385 }
aliguorib161d122009-04-05 19:30:33 +0000386 state = MIG_STATE_ERROR;
387 } else {
388 state = MIG_STATE_COMPLETED;
389 }
Anthony Liguori41ef56e2010-06-02 14:55:25 -0500390 if (migrate_fd_cleanup(s) < 0) {
391 if (old_vm_running) {
392 vm_start();
393 }
394 state = MIG_STATE_ERROR;
395 }
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300396 if (state == MIG_STATE_COMPLETED) {
397 runstate_set(RSTATE_POST_MIGRATE);
398 }
aliguorib161d122009-04-05 19:30:33 +0000399 s->state = state;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200400 notifier_list_notify(&migration_state_notifiers, NULL);
aliguori065e2812008-11-11 16:46:33 +0000401 }
402}
403
404int migrate_fd_get_status(MigrationState *mig_state)
405{
406 FdMigrationState *s = migrate_to_fms(mig_state);
407 return s->state;
408}
409
410void migrate_fd_cancel(MigrationState *mig_state)
411{
412 FdMigrationState *s = migrate_to_fms(mig_state);
413
414 if (s->state != MIG_STATE_ACTIVE)
415 return;
416
malcd0f2c4c2010-02-07 02:03:50 +0300417 DPRINTF("cancelling migration\n");
aliguori065e2812008-11-11 16:46:33 +0000418
419 s->state = MIG_STATE_CANCELLED;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200420 notifier_list_notify(&migration_state_notifiers, NULL);
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100421 qemu_savevm_state_cancel(s->mon, s->file);
aliguori065e2812008-11-11 16:46:33 +0000422
423 migrate_fd_cleanup(s);
424}
425
426void migrate_fd_release(MigrationState *mig_state)
427{
428 FdMigrationState *s = migrate_to_fms(mig_state);
429
malcd0f2c4c2010-02-07 02:03:50 +0300430 DPRINTF("releasing state\n");
aliguori065e2812008-11-11 16:46:33 +0000431
432 if (s->state == MIG_STATE_ACTIVE) {
433 s->state = MIG_STATE_CANCELLED;
Jan Kiszka9e8dd452011-06-20 14:06:26 +0200434 notifier_list_notify(&migration_state_notifiers, NULL);
aliguori065e2812008-11-11 16:46:33 +0000435 migrate_fd_cleanup(s);
436 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500437 g_free(s);
aliguori065e2812008-11-11 16:46:33 +0000438}
439
440void migrate_fd_wait_for_unfreeze(void *opaque)
441{
442 FdMigrationState *s = opaque;
443 int ret;
444
malcd0f2c4c2010-02-07 02:03:50 +0300445 DPRINTF("wait for unfreeze\n");
aliguori065e2812008-11-11 16:46:33 +0000446 if (s->state != MIG_STATE_ACTIVE)
447 return;
448
449 do {
450 fd_set wfds;
451
452 FD_ZERO(&wfds);
453 FD_SET(s->fd, &wfds);
454
455 ret = select(s->fd + 1, NULL, &wfds, NULL, NULL);
456 } while (ret == -1 && (s->get_error(s)) == EINTR);
457}
458
459int migrate_fd_close(void *opaque)
460{
461 FdMigrationState *s = opaque;
Uri Lubline19252d2009-06-08 14:28:01 +0300462
Jan Kiszka84ec6552011-08-05 09:11:26 +0200463 if (s->mon) {
464 monitor_resume(s->mon);
465 }
Uri Lubline19252d2009-06-08 14:28:01 +0300466 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
aliguori065e2812008-11-11 16:46:33 +0000467 return s->close(s);
468}
Gerd Hoffmann99a0db92010-12-13 17:30:12 +0100469
470void add_migration_state_change_notifier(Notifier *notify)
471{
472 notifier_list_add(&migration_state_notifiers, notify);
473}
474
475void remove_migration_state_change_notifier(Notifier *notify)
476{
477 notifier_list_remove(&migration_state_notifiers, notify);
478}
479
480int get_migration_state(void)
481{
482 if (current_migration) {
483 return migrate_fd_get_status(current_migration);
484 } else {
485 return MIG_STATE_ERROR;
486 }
487}