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_info_migrate(Monitor
*mon
)
123 MigrationState
*s
= current_migration
;
126 monitor_printf(mon
, "Migration status: ");
127 switch (s
->get_status(s
)) {
128 case MIG_STATE_ACTIVE
:
129 monitor_printf(mon
, "active\n");
130 monitor_printf(mon
, "transferred ram: %" PRIu64
" kbytes\n", ram_bytes_transferred() >> 10);
131 monitor_printf(mon
, "remaining ram: %" PRIu64
" kbytes\n", ram_bytes_remaining() >> 10);
132 monitor_printf(mon
, "total ram: %" PRIu64
" kbytes\n", ram_bytes_total() >> 10);
134 case MIG_STATE_COMPLETED
:
135 monitor_printf(mon
, "completed\n");
137 case MIG_STATE_ERROR
:
138 monitor_printf(mon
, "failed\n");
140 case MIG_STATE_CANCELLED
:
141 monitor_printf(mon
, "cancelled\n");
147 /* shared migration helpers */
149 void migrate_fd_monitor_suspend(FdMigrationState
*s
)
151 s
->mon_resume
= cur_mon
;
152 if (monitor_suspend(cur_mon
) == 0)
153 dprintf("suspending monitor\n");
155 monitor_printf(cur_mon
, "terminal does not allow synchronous "
156 "migration, continuing detached\n");
159 void migrate_fd_error(FdMigrationState
*s
)
161 dprintf("setting error state\n");
162 s
->state
= MIG_STATE_ERROR
;
163 migrate_fd_cleanup(s
);
166 void migrate_fd_cleanup(FdMigrationState
*s
)
168 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
171 dprintf("closing file\n");
172 qemu_fclose(s
->file
);
178 /* Don't resume monitor until we've flushed all of the buffers */
180 monitor_resume(s
->mon_resume
);
185 void migrate_fd_put_notify(void *opaque
)
187 FdMigrationState
*s
= opaque
;
189 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
190 qemu_file_put_notify(s
->file
);
193 ssize_t
migrate_fd_put_buffer(void *opaque
, const void *data
, size_t size
)
195 FdMigrationState
*s
= opaque
;
199 ret
= s
->write(s
, data
, size
);
200 } while (ret
== -1 && ((s
->get_error(s
)) == EINTR
));
203 ret
= -(s
->get_error(s
));
206 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, migrate_fd_put_notify
, s
);
211 void migrate_fd_connect(FdMigrationState
*s
)
215 s
->file
= qemu_fopen_ops_buffered(s
,
217 migrate_fd_put_buffer
,
218 migrate_fd_put_ready
,
219 migrate_fd_wait_for_unfreeze
,
222 dprintf("beginning savevm\n");
223 ret
= qemu_savevm_state_begin(s
->file
);
225 dprintf("failed, %d\n", ret
);
230 migrate_fd_put_ready(s
);
233 void migrate_fd_put_ready(void *opaque
)
235 FdMigrationState
*s
= opaque
;
237 if (s
->state
!= MIG_STATE_ACTIVE
) {
238 dprintf("put_ready returning because of non-active state\n");
242 dprintf("iterate\n");
243 if (qemu_savevm_state_iterate(s
->file
) == 1) {
245 dprintf("done iterating\n");
249 if ((qemu_savevm_state_complete(s
->file
)) < 0) {
251 state
= MIG_STATE_ERROR
;
253 state
= MIG_STATE_COMPLETED
;
255 migrate_fd_cleanup(s
);
260 int migrate_fd_get_status(MigrationState
*mig_state
)
262 FdMigrationState
*s
= migrate_to_fms(mig_state
);
266 void migrate_fd_cancel(MigrationState
*mig_state
)
268 FdMigrationState
*s
= migrate_to_fms(mig_state
);
270 if (s
->state
!= MIG_STATE_ACTIVE
)
273 dprintf("cancelling migration\n");
275 s
->state
= MIG_STATE_CANCELLED
;
277 migrate_fd_cleanup(s
);
280 void migrate_fd_release(MigrationState
*mig_state
)
282 FdMigrationState
*s
= migrate_to_fms(mig_state
);
284 dprintf("releasing state\n");
286 if (s
->state
== MIG_STATE_ACTIVE
) {
287 s
->state
= MIG_STATE_CANCELLED
;
288 migrate_fd_cleanup(s
);
293 void migrate_fd_wait_for_unfreeze(void *opaque
)
295 FdMigrationState
*s
= opaque
;
298 dprintf("wait for unfreeze\n");
299 if (s
->state
!= MIG_STATE_ACTIVE
)
306 FD_SET(s
->fd
, &wfds
);
308 ret
= select(s
->fd
+ 1, NULL
, &wfds
, NULL
, NULL
);
309 } while (ret
== -1 && (s
->get_error(s
)) == EINTR
);
312 int migrate_fd_close(void *opaque
)
314 FdMigrationState
*s
= opaque
;
316 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);