]>
Commit | Line | Data |
---|---|---|
5bb7910a AL |
1 | /* |
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" | |
376253ec | 16 | #include "monitor.h" |
065e2813 AL |
17 | #include "buffered_file.h" |
18 | #include "sysemu.h" | |
19 | #include "block.h" | |
20 | #include "qemu_socket.h" | |
21 | ||
22 | //#define DEBUG_MIGRATION | |
23 | ||
24 | #ifdef DEBUG_MIGRATION | |
25 | #define dprintf(fmt, ...) \ | |
26 | do { printf("migration: " fmt, ## __VA_ARGS__); } while (0) | |
27 | #else | |
28 | #define dprintf(fmt, ...) \ | |
29 | do { } while (0) | |
30 | #endif | |
5bb7910a AL |
31 | |
32 | /* Migration speed throttling */ | |
33 | static uint32_t max_throttle = (32 << 20); | |
34 | ||
35 | static MigrationState *current_migration; | |
36 | ||
37 | void qemu_start_incoming_migration(const char *uri) | |
38 | { | |
34c9dd8e AL |
39 | const char *p; |
40 | ||
41 | if (strstart(uri, "tcp:", &p)) | |
42 | tcp_start_incoming_migration(p); | |
065e2813 AL |
43 | #if !defined(WIN32) |
44 | else if (strstart(uri, "exec:", &p)) | |
45 | exec_start_incoming_migration(p); | |
46 | #endif | |
34c9dd8e AL |
47 | else |
48 | fprintf(stderr, "unknown migration protocol: %s\n", uri); | |
5bb7910a AL |
49 | } |
50 | ||
376253ec | 51 | void do_migrate(Monitor *mon, int detach, const char *uri) |
5bb7910a | 52 | { |
34c9dd8e AL |
53 | MigrationState *s = NULL; |
54 | const char *p; | |
55 | ||
56 | if (strstart(uri, "tcp:", &p)) | |
ff8d81d8 | 57 | s = tcp_start_outgoing_migration(p, max_throttle, detach); |
065e2813 AL |
58 | #if !defined(WIN32) |
59 | else if (strstart(uri, "exec:", &p)) | |
60 | s = exec_start_outgoing_migration(p, max_throttle, detach); | |
61 | #endif | |
34c9dd8e | 62 | else |
376253ec | 63 | monitor_printf(mon, "unknown migration protocol: %s\n", uri); |
34c9dd8e AL |
64 | |
65 | if (s == NULL) | |
376253ec | 66 | monitor_printf(mon, "migration failed\n"); |
34c9dd8e | 67 | else { |
ff8d81d8 AL |
68 | if (current_migration) |
69 | current_migration->release(current_migration); | |
34c9dd8e | 70 | |
ff8d81d8 | 71 | current_migration = s; |
34c9dd8e | 72 | } |
5bb7910a AL |
73 | } |
74 | ||
376253ec | 75 | void do_migrate_cancel(Monitor *mon) |
5bb7910a AL |
76 | { |
77 | MigrationState *s = current_migration; | |
78 | ||
79 | if (s) | |
ff8d81d8 | 80 | s->cancel(s); |
5bb7910a AL |
81 | } |
82 | ||
376253ec | 83 | void do_migrate_set_speed(Monitor *mon, const char *value) |
5bb7910a AL |
84 | { |
85 | double d; | |
86 | char *ptr; | |
daa91de2 | 87 | FdMigrationState *s; |
5bb7910a AL |
88 | |
89 | d = strtod(value, &ptr); | |
90 | switch (*ptr) { | |
91 | case 'G': case 'g': | |
ff8d81d8 | 92 | d *= 1024; |
5bb7910a | 93 | case 'M': case 'm': |
ff8d81d8 | 94 | d *= 1024; |
5bb7910a | 95 | case 'K': case 'k': |
ff8d81d8 | 96 | d *= 1024; |
5bb7910a | 97 | default: |
ff8d81d8 | 98 | break; |
5bb7910a AL |
99 | } |
100 | ||
101 | max_throttle = (uint32_t)d; | |
daa91de2 GC |
102 | s = migrate_to_fms(current_migration); |
103 | ||
104 | if (s) { | |
105 | qemu_file_set_rate_limit(s->file, max_throttle); | |
106 | } | |
107 | ||
5bb7910a AL |
108 | } |
109 | ||
376253ec | 110 | void do_info_migrate(Monitor *mon) |
5bb7910a AL |
111 | { |
112 | MigrationState *s = current_migration; | |
376253ec | 113 | |
5bb7910a | 114 | if (s) { |
376253ec | 115 | monitor_printf(mon, "Migration status: "); |
ff8d81d8 AL |
116 | switch (s->get_status(s)) { |
117 | case MIG_STATE_ACTIVE: | |
376253ec | 118 | monitor_printf(mon, "active\n"); |
9f9e28cd GC |
119 | monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", ram_bytes_transferred() >> 10); |
120 | monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n", ram_bytes_remaining() >> 10); | |
121 | monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n", ram_bytes_total() >> 10); | |
ff8d81d8 AL |
122 | break; |
123 | case MIG_STATE_COMPLETED: | |
376253ec | 124 | monitor_printf(mon, "completed\n"); |
ff8d81d8 AL |
125 | break; |
126 | case MIG_STATE_ERROR: | |
376253ec | 127 | monitor_printf(mon, "failed\n"); |
ff8d81d8 AL |
128 | break; |
129 | case MIG_STATE_CANCELLED: | |
376253ec | 130 | monitor_printf(mon, "cancelled\n"); |
ff8d81d8 AL |
131 | break; |
132 | } | |
5bb7910a AL |
133 | } |
134 | } | |
135 | ||
065e2813 AL |
136 | /* shared migration helpers */ |
137 | ||
731b0364 AL |
138 | void migrate_fd_monitor_suspend(FdMigrationState *s) |
139 | { | |
140 | s->mon_resume = cur_mon; | |
cde76ee1 AL |
141 | if (monitor_suspend(cur_mon) == 0) |
142 | dprintf("suspending monitor\n"); | |
143 | else | |
144 | monitor_printf(cur_mon, "terminal does not allow synchronous " | |
145 | "migration, continuing detached\n"); | |
731b0364 AL |
146 | } |
147 | ||
065e2813 AL |
148 | void migrate_fd_error(FdMigrationState *s) |
149 | { | |
150 | dprintf("setting error state\n"); | |
151 | s->state = MIG_STATE_ERROR; | |
152 | migrate_fd_cleanup(s); | |
153 | } | |
154 | ||
155 | void migrate_fd_cleanup(FdMigrationState *s) | |
156 | { | |
157 | qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); | |
158 | ||
159 | if (s->file) { | |
160 | dprintf("closing file\n"); | |
161 | qemu_fclose(s->file); | |
162 | } | |
163 | ||
164 | if (s->fd != -1) | |
165 | close(s->fd); | |
166 | ||
167 | /* Don't resume monitor until we've flushed all of the buffers */ | |
731b0364 AL |
168 | if (s->mon_resume) |
169 | monitor_resume(s->mon_resume); | |
065e2813 AL |
170 | |
171 | s->fd = -1; | |
172 | } | |
173 | ||
174 | void migrate_fd_put_notify(void *opaque) | |
175 | { | |
176 | FdMigrationState *s = opaque; | |
177 | ||
178 | qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL); | |
179 | qemu_file_put_notify(s->file); | |
180 | } | |
181 | ||
182 | ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size) | |
183 | { | |
184 | FdMigrationState *s = opaque; | |
185 | ssize_t ret; | |
186 | ||
187 | do { | |
188 | ret = s->write(s, data, size); | |
95b134ea | 189 | } while (ret == -1 && ((s->get_error(s)) == EINTR)); |
065e2813 AL |
190 | |
191 | if (ret == -1) | |
192 | ret = -(s->get_error(s)); | |
193 | ||
194 | if (ret == -EAGAIN) | |
195 | qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s); | |
196 | ||
197 | return ret; | |
198 | } | |
199 | ||
200 | void migrate_fd_connect(FdMigrationState *s) | |
201 | { | |
202 | int ret; | |
203 | ||
204 | s->file = qemu_fopen_ops_buffered(s, | |
205 | s->bandwidth_limit, | |
206 | migrate_fd_put_buffer, | |
207 | migrate_fd_put_ready, | |
208 | migrate_fd_wait_for_unfreeze, | |
209 | migrate_fd_close); | |
210 | ||
211 | dprintf("beginning savevm\n"); | |
212 | ret = qemu_savevm_state_begin(s->file); | |
213 | if (ret < 0) { | |
214 | dprintf("failed, %d\n", ret); | |
215 | migrate_fd_error(s); | |
216 | return; | |
217 | } | |
218 | ||
219 | migrate_fd_put_ready(s); | |
220 | } | |
221 | ||
222 | void migrate_fd_put_ready(void *opaque) | |
223 | { | |
224 | FdMigrationState *s = opaque; | |
225 | ||
226 | if (s->state != MIG_STATE_ACTIVE) { | |
227 | dprintf("put_ready returning because of non-active state\n"); | |
228 | return; | |
229 | } | |
230 | ||
231 | dprintf("iterate\n"); | |
232 | if (qemu_savevm_state_iterate(s->file) == 1) { | |
b161d123 | 233 | int state; |
065e2813 AL |
234 | dprintf("done iterating\n"); |
235 | vm_stop(0); | |
236 | ||
237 | bdrv_flush_all(); | |
b161d123 AL |
238 | if ((qemu_savevm_state_complete(s->file)) < 0) { |
239 | vm_start(); | |
240 | state = MIG_STATE_ERROR; | |
241 | } else { | |
242 | state = MIG_STATE_COMPLETED; | |
243 | } | |
065e2813 | 244 | migrate_fd_cleanup(s); |
b161d123 | 245 | s->state = state; |
065e2813 AL |
246 | } |
247 | } | |
248 | ||
249 | int migrate_fd_get_status(MigrationState *mig_state) | |
250 | { | |
251 | FdMigrationState *s = migrate_to_fms(mig_state); | |
252 | return s->state; | |
253 | } | |
254 | ||
255 | void migrate_fd_cancel(MigrationState *mig_state) | |
256 | { | |
257 | FdMigrationState *s = migrate_to_fms(mig_state); | |
258 | ||
259 | if (s->state != MIG_STATE_ACTIVE) | |
260 | return; | |
261 | ||
262 | dprintf("cancelling migration\n"); | |
263 | ||
264 | s->state = MIG_STATE_CANCELLED; | |
265 | ||
266 | migrate_fd_cleanup(s); | |
267 | } | |
268 | ||
269 | void migrate_fd_release(MigrationState *mig_state) | |
270 | { | |
271 | FdMigrationState *s = migrate_to_fms(mig_state); | |
272 | ||
273 | dprintf("releasing state\n"); | |
274 | ||
275 | if (s->state == MIG_STATE_ACTIVE) { | |
276 | s->state = MIG_STATE_CANCELLED; | |
277 | migrate_fd_cleanup(s); | |
278 | } | |
279 | free(s); | |
280 | } | |
281 | ||
282 | void migrate_fd_wait_for_unfreeze(void *opaque) | |
283 | { | |
284 | FdMigrationState *s = opaque; | |
285 | int ret; | |
286 | ||
287 | dprintf("wait for unfreeze\n"); | |
288 | if (s->state != MIG_STATE_ACTIVE) | |
289 | return; | |
290 | ||
291 | do { | |
292 | fd_set wfds; | |
293 | ||
294 | FD_ZERO(&wfds); | |
295 | FD_SET(s->fd, &wfds); | |
296 | ||
297 | ret = select(s->fd + 1, NULL, &wfds, NULL, NULL); | |
298 | } while (ret == -1 && (s->get_error(s)) == EINTR); | |
299 | } | |
300 | ||
301 | int migrate_fd_close(void *opaque) | |
302 | { | |
303 | FdMigrationState *s = opaque; | |
304 | return s->close(s); | |
305 | } |