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.
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
16 #include "qemu-common.h"
17 #include "migration/migration.h"
18 #include "monitor/monitor.h"
19 #include "migration/qemu-file.h"
20 #include "sysemu/sysemu.h"
21 #include "block/block.h"
22 #include "qemu/sockets.h"
23 #include "migration/block.h"
24 #include "qemu/thread.h"
25 #include "qmp-commands.h"
28 //#define DEBUG_MIGRATION
30 #ifdef DEBUG_MIGRATION
31 #define DPRINTF(fmt, ...) \
32 do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
34 #define DPRINTF(fmt, ...) \
46 #define MAX_THROTTLE (32 << 20) /* Migration speed throttling */
48 /* Amount of time to allocate to each "chunk" of bandwidth-throttled
50 #define BUFFER_DELAY 100
51 #define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
53 /* Migration XBZRLE default cache size */
54 #define DEFAULT_MIGRATE_CACHE_SIZE (64 * 1024 * 1024)
56 static NotifierList migration_state_notifiers
=
57 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers
);
59 /* When we add fault tolerance, we could have several
60 migrations at once. For now we don't need to add
61 dynamic creation of migration */
63 MigrationState
*migrate_get_current(void)
65 static MigrationState current_migration
= {
66 .state
= MIG_STATE_SETUP
,
67 .bandwidth_limit
= MAX_THROTTLE
,
68 .xbzrle_cache_size
= DEFAULT_MIGRATE_CACHE_SIZE
,
71 return ¤t_migration
;
74 void qemu_start_incoming_migration(const char *uri
, Error
**errp
)
78 if (strstart(uri
, "tcp:", &p
))
79 tcp_start_incoming_migration(p
, errp
);
81 else if (strstart(uri
, "exec:", &p
))
82 exec_start_incoming_migration(p
, errp
);
83 else if (strstart(uri
, "unix:", &p
))
84 unix_start_incoming_migration(p
, errp
);
85 else if (strstart(uri
, "fd:", &p
))
86 fd_start_incoming_migration(p
, errp
);
89 error_setg(errp
, "unknown migration protocol: %s", uri
);
93 static void process_incoming_migration_co(void *opaque
)
98 ret
= qemu_loadvm_state(f
);
101 fprintf(stderr
, "load of migration failed\n");
104 qemu_announce_self();
105 DPRINTF("successfully loaded vm state\n");
107 bdrv_clear_incoming_migration_all();
108 /* Make sure all file formats flush their mutable metadata */
109 bdrv_invalidate_cache_all();
114 runstate_set(RUN_STATE_PAUSED
);
118 void process_incoming_migration(QEMUFile
*f
)
120 Coroutine
*co
= qemu_coroutine_create(process_incoming_migration_co
);
121 int fd
= qemu_get_fd(f
);
124 socket_set_nonblock(fd
);
125 qemu_coroutine_enter(co
, f
);
128 /* amount of nanoseconds we are willing to wait for migration to be down.
129 * the choice of nanoseconds is because it is the maximum resolution that
130 * get_clock() can achieve. It is an internal measure. All user-visible
131 * units must be in seconds */
132 static uint64_t max_downtime
= 30000000;
134 uint64_t migrate_max_downtime(void)
139 MigrationCapabilityStatusList
*qmp_query_migrate_capabilities(Error
**errp
)
141 MigrationCapabilityStatusList
*head
= NULL
;
142 MigrationCapabilityStatusList
*caps
;
143 MigrationState
*s
= migrate_get_current();
146 for (i
= 0; i
< MIGRATION_CAPABILITY_MAX
; i
++) {
148 head
= g_malloc0(sizeof(*caps
));
151 caps
->next
= g_malloc0(sizeof(*caps
));
155 g_malloc(sizeof(*caps
->value
));
156 caps
->value
->capability
= i
;
157 caps
->value
->state
= s
->enabled_capabilities
[i
];
163 static void get_xbzrle_cache_stats(MigrationInfo
*info
)
165 if (migrate_use_xbzrle()) {
166 info
->has_xbzrle_cache
= true;
167 info
->xbzrle_cache
= g_malloc0(sizeof(*info
->xbzrle_cache
));
168 info
->xbzrle_cache
->cache_size
= migrate_xbzrle_cache_size();
169 info
->xbzrle_cache
->bytes
= xbzrle_mig_bytes_transferred();
170 info
->xbzrle_cache
->pages
= xbzrle_mig_pages_transferred();
171 info
->xbzrle_cache
->cache_miss
= xbzrle_mig_pages_cache_miss();
172 info
->xbzrle_cache
->overflow
= xbzrle_mig_pages_overflow();
176 MigrationInfo
*qmp_query_migrate(Error
**errp
)
178 MigrationInfo
*info
= g_malloc0(sizeof(*info
));
179 MigrationState
*s
= migrate_get_current();
182 case MIG_STATE_SETUP
:
183 /* no migration has happened ever */
185 case MIG_STATE_ACTIVE
:
186 info
->has_status
= true;
187 info
->status
= g_strdup("active");
188 info
->has_total_time
= true;
189 info
->total_time
= qemu_get_clock_ms(rt_clock
)
191 info
->has_expected_downtime
= true;
192 info
->expected_downtime
= s
->expected_downtime
;
194 info
->has_ram
= true;
195 info
->ram
= g_malloc0(sizeof(*info
->ram
));
196 info
->ram
->transferred
= ram_bytes_transferred();
197 info
->ram
->remaining
= ram_bytes_remaining();
198 info
->ram
->total
= ram_bytes_total();
199 info
->ram
->duplicate
= dup_mig_pages_transferred();
200 info
->ram
->normal
= norm_mig_pages_transferred();
201 info
->ram
->normal_bytes
= norm_mig_bytes_transferred();
202 info
->ram
->dirty_pages_rate
= s
->dirty_pages_rate
;
205 if (blk_mig_active()) {
206 info
->has_disk
= true;
207 info
->disk
= g_malloc0(sizeof(*info
->disk
));
208 info
->disk
->transferred
= blk_mig_bytes_transferred();
209 info
->disk
->remaining
= blk_mig_bytes_remaining();
210 info
->disk
->total
= blk_mig_bytes_total();
213 get_xbzrle_cache_stats(info
);
215 case MIG_STATE_COMPLETED
:
216 get_xbzrle_cache_stats(info
);
218 info
->has_status
= true;
219 info
->status
= g_strdup("completed");
220 info
->total_time
= s
->total_time
;
221 info
->has_downtime
= true;
222 info
->downtime
= s
->downtime
;
224 info
->has_ram
= true;
225 info
->ram
= g_malloc0(sizeof(*info
->ram
));
226 info
->ram
->transferred
= ram_bytes_transferred();
227 info
->ram
->remaining
= 0;
228 info
->ram
->total
= ram_bytes_total();
229 info
->ram
->duplicate
= dup_mig_pages_transferred();
230 info
->ram
->normal
= norm_mig_pages_transferred();
231 info
->ram
->normal_bytes
= norm_mig_bytes_transferred();
233 case MIG_STATE_ERROR
:
234 info
->has_status
= true;
235 info
->status
= g_strdup("failed");
237 case MIG_STATE_CANCELLED
:
238 info
->has_status
= true;
239 info
->status
= g_strdup("cancelled");
246 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList
*params
,
249 MigrationState
*s
= migrate_get_current();
250 MigrationCapabilityStatusList
*cap
;
252 if (s
->state
== MIG_STATE_ACTIVE
) {
253 error_set(errp
, QERR_MIGRATION_ACTIVE
);
257 for (cap
= params
; cap
; cap
= cap
->next
) {
258 s
->enabled_capabilities
[cap
->value
->capability
] = cap
->value
->state
;
262 /* shared migration helpers */
264 static void migrate_fd_cleanup(MigrationState
*s
)
267 DPRINTF("closing file\n");
268 qemu_fclose(s
->file
);
273 assert(s
->state
!= MIG_STATE_ACTIVE
);
275 if (s
->state
!= MIG_STATE_COMPLETED
) {
276 qemu_savevm_state_cancel();
279 notifier_list_notify(&migration_state_notifiers
, s
);
282 static void migrate_finish_set_state(MigrationState
*s
, int new_state
)
284 if (__sync_val_compare_and_swap(&s
->state
, MIG_STATE_ACTIVE
,
285 new_state
) == new_state
) {
286 trace_migrate_set_state(new_state
);
290 void migrate_fd_error(MigrationState
*s
)
292 DPRINTF("setting error state\n");
293 migrate_finish_set_state(s
, MIG_STATE_ERROR
);
294 migrate_fd_cleanup(s
);
297 static void migrate_fd_completed(MigrationState
*s
)
299 DPRINTF("setting completed state\n");
300 migrate_finish_set_state(s
, MIG_STATE_COMPLETED
);
301 migrate_fd_cleanup(s
);
304 static ssize_t
migrate_fd_put_buffer(MigrationState
*s
, const void *data
,
309 if (s
->state
!= MIG_STATE_ACTIVE
) {
314 ret
= s
->write(s
, data
, size
);
315 } while (ret
== -1 && ((s
->get_error(s
)) == EINTR
));
318 ret
= -(s
->get_error(s
));
323 static void migrate_fd_cancel(MigrationState
*s
)
325 DPRINTF("cancelling migration\n");
327 migrate_finish_set_state(s
, MIG_STATE_CANCELLED
);
328 migrate_fd_cleanup(s
);
331 int migrate_fd_close(MigrationState
*s
)
341 void add_migration_state_change_notifier(Notifier
*notify
)
343 notifier_list_add(&migration_state_notifiers
, notify
);
346 void remove_migration_state_change_notifier(Notifier
*notify
)
348 notifier_remove(notify
);
351 bool migration_is_active(MigrationState
*s
)
353 return s
->state
== MIG_STATE_ACTIVE
;
356 bool migration_has_finished(MigrationState
*s
)
358 return s
->state
== MIG_STATE_COMPLETED
;
361 bool migration_has_failed(MigrationState
*s
)
363 return (s
->state
== MIG_STATE_CANCELLED
||
364 s
->state
== MIG_STATE_ERROR
);
367 static MigrationState
*migrate_init(const MigrationParams
*params
)
369 MigrationState
*s
= migrate_get_current();
370 int64_t bandwidth_limit
= s
->bandwidth_limit
;
371 bool enabled_capabilities
[MIGRATION_CAPABILITY_MAX
];
372 int64_t xbzrle_cache_size
= s
->xbzrle_cache_size
;
374 memcpy(enabled_capabilities
, s
->enabled_capabilities
,
375 sizeof(enabled_capabilities
));
377 memset(s
, 0, sizeof(*s
));
378 s
->bandwidth_limit
= bandwidth_limit
;
380 memcpy(s
->enabled_capabilities
, enabled_capabilities
,
381 sizeof(enabled_capabilities
));
382 s
->xbzrle_cache_size
= xbzrle_cache_size
;
384 s
->bandwidth_limit
= bandwidth_limit
;
385 s
->state
= MIG_STATE_SETUP
;
386 trace_migrate_set_state(MIG_STATE_SETUP
);
388 s
->total_time
= qemu_get_clock_ms(rt_clock
);
392 static GSList
*migration_blockers
;
394 void migrate_add_blocker(Error
*reason
)
396 migration_blockers
= g_slist_prepend(migration_blockers
, reason
);
399 void migrate_del_blocker(Error
*reason
)
401 migration_blockers
= g_slist_remove(migration_blockers
, reason
);
404 void qmp_migrate(const char *uri
, bool has_blk
, bool blk
,
405 bool has_inc
, bool inc
, bool has_detach
, bool detach
,
408 Error
*local_err
= NULL
;
409 MigrationState
*s
= migrate_get_current();
410 MigrationParams params
;
416 if (s
->state
== MIG_STATE_ACTIVE
) {
417 error_set(errp
, QERR_MIGRATION_ACTIVE
);
421 if (qemu_savevm_state_blocked(errp
)) {
425 if (migration_blockers
) {
426 *errp
= error_copy(migration_blockers
->data
);
430 s
= migrate_init(¶ms
);
432 if (strstart(uri
, "tcp:", &p
)) {
433 tcp_start_outgoing_migration(s
, p
, &local_err
);
435 } else if (strstart(uri
, "exec:", &p
)) {
436 exec_start_outgoing_migration(s
, p
, &local_err
);
437 } else if (strstart(uri
, "unix:", &p
)) {
438 unix_start_outgoing_migration(s
, p
, &local_err
);
439 } else if (strstart(uri
, "fd:", &p
)) {
440 fd_start_outgoing_migration(s
, p
, &local_err
);
443 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "uri", "a valid migration protocol");
449 error_propagate(errp
, local_err
);
454 void qmp_migrate_cancel(Error
**errp
)
456 migrate_fd_cancel(migrate_get_current());
459 void qmp_migrate_set_cache_size(int64_t value
, Error
**errp
)
461 MigrationState
*s
= migrate_get_current();
463 /* Check for truncation */
464 if (value
!= (size_t)value
) {
465 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cache size",
466 "exceeding address space");
470 s
->xbzrle_cache_size
= xbzrle_cache_resize(value
);
473 int64_t qmp_query_migrate_cache_size(Error
**errp
)
475 return migrate_xbzrle_cache_size();
478 void qmp_migrate_set_speed(int64_t value
, Error
**errp
)
486 s
= migrate_get_current();
487 s
->bandwidth_limit
= value
;
488 qemu_file_set_rate_limit(s
->file
, s
->bandwidth_limit
);
491 void qmp_migrate_set_downtime(double value
, Error
**errp
)
494 value
= MAX(0, MIN(UINT64_MAX
, value
));
495 max_downtime
= (uint64_t)value
;
498 int migrate_use_xbzrle(void)
502 s
= migrate_get_current();
504 return s
->enabled_capabilities
[MIGRATION_CAPABILITY_XBZRLE
];
507 int64_t migrate_xbzrle_cache_size(void)
511 s
= migrate_get_current();
513 return s
->xbzrle_cache_size
;
516 /* migration thread support */
519 static void buffered_flush(MigrationState
*s
)
524 DPRINTF("flushing %zu byte(s) of data\n", s
->buffer_size
);
526 if (qemu_file_get_error(s
->file
)) {
530 qemu_fflush(s
->file
);
532 while (s
->bytes_xfer
< s
->xfer_limit
&& offset
< s
->buffer_size
) {
533 size_t to_send
= MIN(s
->buffer_size
- offset
, s
->xfer_limit
- s
->bytes_xfer
);
534 ret
= migrate_fd_put_buffer(s
, s
->buffer
+ offset
, to_send
);
536 DPRINTF("error flushing data, %zd\n", ret
);
539 DPRINTF("flushed %zd byte(s)\n", ret
);
541 s
->bytes_xfer
+= ret
;
545 DPRINTF("flushed %zu of %zu byte(s)\n", offset
, s
->buffer_size
);
546 memmove(s
->buffer
, s
->buffer
+ offset
, s
->buffer_size
- offset
);
547 s
->buffer_size
-= offset
;
550 qemu_file_set_error(s
->file
, ret
);
554 static int buffered_put_buffer(void *opaque
, const uint8_t *buf
,
555 int64_t pos
, int size
)
557 MigrationState
*s
= opaque
;
560 DPRINTF("putting %d bytes at %" PRId64
"\n", size
, pos
);
562 error
= qemu_file_get_error(s
->file
);
564 DPRINTF("flush when error, bailing: %s\n", strerror(-error
));
572 if (size
> (s
->buffer_capacity
- s
->buffer_size
)) {
573 DPRINTF("increasing buffer capacity from %zu by %zu\n",
574 s
->buffer_capacity
, size
+ 1024);
576 s
->buffer_capacity
+= size
+ 1024;
578 s
->buffer
= g_realloc(s
->buffer
, s
->buffer_capacity
);
581 memcpy(s
->buffer
+ s
->buffer_size
, buf
, size
);
582 s
->buffer_size
+= size
;
587 static int buffered_close(void *opaque
)
589 MigrationState
*s
= opaque
;
591 DPRINTF("closing\n");
593 return migrate_fd_close(s
);
596 static int buffered_get_fd(void *opaque
)
598 MigrationState
*s
= opaque
;
604 * The meaning of the return values is:
605 * 0: We can continue sending
607 * negative: There has been an error
609 static int buffered_rate_limit(void *opaque
)
611 MigrationState
*s
= opaque
;
614 ret
= qemu_file_get_error(s
->file
);
619 if (s
->bytes_xfer
>= s
->xfer_limit
) {
626 static int64_t buffered_set_rate_limit(void *opaque
, int64_t new_rate
)
628 MigrationState
*s
= opaque
;
629 if (qemu_file_get_error(s
->file
)) {
632 if (new_rate
> SIZE_MAX
) {
636 s
->xfer_limit
= new_rate
/ XFER_LIMIT_RATIO
;
639 return s
->xfer_limit
;
642 static int64_t buffered_get_rate_limit(void *opaque
)
644 MigrationState
*s
= opaque
;
646 return s
->xfer_limit
;
649 static void *buffered_file_thread(void *opaque
)
651 MigrationState
*s
= opaque
;
652 int64_t initial_time
= qemu_get_clock_ms(rt_clock
);
653 int64_t sleep_time
= 0;
654 int64_t max_size
= 0;
655 int64_t start_time
= initial_time
;
656 bool old_vm_running
= false;
657 bool last_round
= false;
659 qemu_mutex_lock_iothread();
660 DPRINTF("beginning savevm\n");
661 qemu_savevm_state_begin(s
->file
, &s
->params
);
662 qemu_mutex_unlock_iothread();
664 while (s
->state
== MIG_STATE_ACTIVE
) {
665 int64_t current_time
;
666 uint64_t pending_size
;
668 if (s
->bytes_xfer
< s
->xfer_limit
) {
669 qemu_mutex_lock_iothread();
670 DPRINTF("iterate\n");
671 pending_size
= qemu_savevm_state_pending(s
->file
, max_size
);
672 DPRINTF("pending size %lu max %lu\n", pending_size
, max_size
);
673 if (pending_size
&& pending_size
>= max_size
) {
674 qemu_savevm_state_iterate(s
->file
);
676 DPRINTF("done iterating\n");
677 start_time
= qemu_get_clock_ms(rt_clock
);
678 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER
);
679 old_vm_running
= runstate_is_running();
680 vm_stop_force_state(RUN_STATE_FINISH_MIGRATE
);
681 s
->xfer_limit
= INT_MAX
;
682 qemu_savevm_state_complete(s
->file
);
685 qemu_mutex_unlock_iothread();
688 current_time
= qemu_get_clock_ms(rt_clock
);
689 if (current_time
>= initial_time
+ BUFFER_DELAY
) {
690 uint64_t transferred_bytes
= s
->bytes_xfer
;
691 uint64_t time_spent
= current_time
- initial_time
- sleep_time
;
692 double bandwidth
= transferred_bytes
/ time_spent
;
693 max_size
= bandwidth
* migrate_max_downtime() / 1000000;
695 DPRINTF("transferred %" PRIu64
" time_spent %" PRIu64
696 " bandwidth %g max_size %" PRId64
"\n",
697 transferred_bytes
, time_spent
, bandwidth
, max_size
);
698 /* if we haven't sent anything, we don't want to recalculate
699 10000 is a small enough number for our purposes */
700 if (s
->dirty_bytes_rate
&& transferred_bytes
> 10000) {
701 s
->expected_downtime
= s
->dirty_bytes_rate
/ bandwidth
;
706 initial_time
= current_time
;
708 if (!last_round
&& (s
->bytes_xfer
>= s
->xfer_limit
)) {
709 /* usleep expects microseconds */
710 g_usleep((initial_time
+ BUFFER_DELAY
- current_time
)*1000);
711 sleep_time
+= qemu_get_clock_ms(rt_clock
) - current_time
;
714 if (qemu_file_get_error(s
->file
)) {
715 qemu_mutex_lock_iothread();
717 qemu_mutex_unlock_iothread();
718 } else if (last_round
&& s
->buffer_size
== 0) {
719 qemu_mutex_lock_iothread();
720 migrate_fd_completed(s
);
721 qemu_mutex_unlock_iothread();
725 qemu_mutex_lock_iothread();
726 if (s
->state
== MIG_STATE_COMPLETED
) {
727 int64_t end_time
= qemu_get_clock_ms(rt_clock
);
728 s
->total_time
= end_time
- s
->total_time
;
729 s
->downtime
= end_time
- start_time
;
730 runstate_set(RUN_STATE_POSTMIGRATE
);
732 if (old_vm_running
) {
737 qemu_mutex_unlock_iothread();
743 static const QEMUFileOps buffered_file_ops
= {
744 .get_fd
= buffered_get_fd
,
745 .put_buffer
= buffered_put_buffer
,
746 .close
= buffered_close
,
747 .rate_limit
= buffered_rate_limit
,
748 .get_rate_limit
= buffered_get_rate_limit
,
749 .set_rate_limit
= buffered_set_rate_limit
,
752 void migrate_fd_connect(MigrationState
*s
)
754 s
->state
= MIG_STATE_ACTIVE
;
755 trace_migrate_set_state(MIG_STATE_ACTIVE
);
760 s
->buffer_capacity
= 0;
761 /* This is a best 1st approximation. ns to ms */
762 s
->expected_downtime
= max_downtime
/1000000;
764 s
->xfer_limit
= s
->bandwidth_limit
/ XFER_LIMIT_RATIO
;
766 s
->file
= qemu_fopen_ops(s
, &buffered_file_ops
);
768 qemu_thread_create(&s
->thread
, buffered_file_thread
, s
,
769 QEMU_THREAD_DETACHED
);
770 notifier_list_notify(&migration_state_notifiers
, s
);