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"
22 //#define DEBUG_MIGRATION
24 #ifdef DEBUG_MIGRATION
25 #define dprintf(fmt, ...) \
26 do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
28 #define dprintf(fmt, ...) \
32 /* Migration speed throttling */
33 static uint32_t max_throttle
= (32 << 20);
35 static MigrationState
*current_migration
;
37 void qemu_start_incoming_migration(const char *uri
)
41 if (strstart(uri
, "tcp:", &p
))
42 tcp_start_incoming_migration(p
);
44 else if (strstart(uri
, "exec:", &p
))
45 exec_start_incoming_migration(p
);
48 fprintf(stderr
, "unknown migration protocol: %s\n", uri
);
51 void do_migrate(Monitor
*mon
, int detach
, const char *uri
)
53 MigrationState
*s
= NULL
;
56 if (strstart(uri
, "tcp:", &p
))
57 s
= tcp_start_outgoing_migration(p
, max_throttle
, detach
);
59 else if (strstart(uri
, "exec:", &p
))
60 s
= exec_start_outgoing_migration(p
, max_throttle
, detach
);
63 monitor_printf(mon
, "unknown migration protocol: %s\n", uri
);
66 monitor_printf(mon
, "migration failed\n");
68 if (current_migration
)
69 current_migration
->release(current_migration
);
71 current_migration
= s
;
75 void do_migrate_cancel(Monitor
*mon
)
77 MigrationState
*s
= current_migration
;
83 void do_migrate_set_speed(Monitor
*mon
, const char *value
)
89 d
= strtod(value
, &ptr
);
101 max_throttle
= (uint32_t)d
;
102 s
= migrate_to_fms(current_migration
);
105 qemu_file_set_rate_limit(s
->file
, max_throttle
);
110 /* amount of nanoseconds we are willing to wait for migration to be down.
111 * the choice of nanoseconds is because it is the maximum resolution that
112 * get_clock() can achieve. It is an internal measure. All user-visible
113 * units must be in seconds */
114 static uint64_t max_downtime
= 30000000;
116 uint64_t migrate_max_downtime(void)
121 void do_migrate_set_downtime(Monitor
*mon
, const char *value
)
126 d
= strtod(value
, &ptr
);
127 if (!strcmp(ptr
,"ms")) {
129 } else if (!strcmp(ptr
,"us")) {
131 } else if (!strcmp(ptr
,"ns")) {
133 /* all else considered to be seconds */
137 max_downtime
= (uint64_t)d
;
140 void do_info_migrate(Monitor
*mon
)
142 MigrationState
*s
= current_migration
;
145 monitor_printf(mon
, "Migration status: ");
146 switch (s
->get_status(s
)) {
147 case MIG_STATE_ACTIVE
:
148 monitor_printf(mon
, "active\n");
149 monitor_printf(mon
, "transferred ram: %" PRIu64
" kbytes\n", ram_bytes_transferred() >> 10);
150 monitor_printf(mon
, "remaining ram: %" PRIu64
" kbytes\n", ram_bytes_remaining() >> 10);
151 monitor_printf(mon
, "total ram: %" PRIu64
" kbytes\n", ram_bytes_total() >> 10);
153 case MIG_STATE_COMPLETED
:
154 monitor_printf(mon
, "completed\n");
156 case MIG_STATE_ERROR
:
157 monitor_printf(mon
, "failed\n");
159 case MIG_STATE_CANCELLED
:
160 monitor_printf(mon
, "cancelled\n");
166 /* shared migration helpers */
168 void migrate_fd_monitor_suspend(FdMigrationState
*s
)
170 s
->mon_resume
= cur_mon
;
171 if (monitor_suspend(cur_mon
) == 0)
172 dprintf("suspending monitor\n");
174 monitor_printf(cur_mon
, "terminal does not allow synchronous "
175 "migration, continuing detached\n");
178 void migrate_fd_error(FdMigrationState
*s
)
180 dprintf("setting error state\n");
181 s
->state
= MIG_STATE_ERROR
;
182 migrate_fd_cleanup(s
);
185 void migrate_fd_cleanup(FdMigrationState
*s
)
187 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
190 dprintf("closing file\n");
191 qemu_fclose(s
->file
);
197 /* Don't resume monitor until we've flushed all of the buffers */
199 monitor_resume(s
->mon_resume
);
204 void migrate_fd_put_notify(void *opaque
)
206 FdMigrationState
*s
= opaque
;
208 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
209 qemu_file_put_notify(s
->file
);
212 ssize_t
migrate_fd_put_buffer(void *opaque
, const void *data
, size_t size
)
214 FdMigrationState
*s
= opaque
;
218 ret
= s
->write(s
, data
, size
);
219 } while (ret
== -1 && ((s
->get_error(s
)) == EINTR
));
222 ret
= -(s
->get_error(s
));
225 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, migrate_fd_put_notify
, s
);
230 void migrate_fd_connect(FdMigrationState
*s
)
234 s
->file
= qemu_fopen_ops_buffered(s
,
236 migrate_fd_put_buffer
,
237 migrate_fd_put_ready
,
238 migrate_fd_wait_for_unfreeze
,
241 dprintf("beginning savevm\n");
242 ret
= qemu_savevm_state_begin(s
->file
);
244 dprintf("failed, %d\n", ret
);
249 migrate_fd_put_ready(s
);
252 void migrate_fd_put_ready(void *opaque
)
254 FdMigrationState
*s
= opaque
;
256 if (s
->state
!= MIG_STATE_ACTIVE
) {
257 dprintf("put_ready returning because of non-active state\n");
261 dprintf("iterate\n");
262 if (qemu_savevm_state_iterate(s
->file
) == 1) {
264 dprintf("done iterating\n");
268 if ((qemu_savevm_state_complete(s
->file
)) < 0) {
270 state
= MIG_STATE_ERROR
;
272 state
= MIG_STATE_COMPLETED
;
274 migrate_fd_cleanup(s
);
279 int migrate_fd_get_status(MigrationState
*mig_state
)
281 FdMigrationState
*s
= migrate_to_fms(mig_state
);
285 void migrate_fd_cancel(MigrationState
*mig_state
)
287 FdMigrationState
*s
= migrate_to_fms(mig_state
);
289 if (s
->state
!= MIG_STATE_ACTIVE
)
292 dprintf("cancelling migration\n");
294 s
->state
= MIG_STATE_CANCELLED
;
296 migrate_fd_cleanup(s
);
299 void migrate_fd_release(MigrationState
*mig_state
)
301 FdMigrationState
*s
= migrate_to_fms(mig_state
);
303 dprintf("releasing state\n");
305 if (s
->state
== MIG_STATE_ACTIVE
) {
306 s
->state
= MIG_STATE_CANCELLED
;
307 migrate_fd_cleanup(s
);
312 void migrate_fd_wait_for_unfreeze(void *opaque
)
314 FdMigrationState
*s
= opaque
;
317 dprintf("wait for unfreeze\n");
318 if (s
->state
!= MIG_STATE_ACTIVE
)
325 FD_SET(s
->fd
, &wfds
);
327 ret
= select(s
->fd
+ 1, NULL
, &wfds
, NULL
, NULL
);
328 } while (ret
== -1 && (s
->get_error(s
)) == EINTR
);
331 int migrate_fd_close(void *opaque
)
333 FdMigrationState
*s
= opaque
;
335 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);