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(void *opaque
)
266 MigrationState
*s
= opaque
;
268 qemu_bh_delete(s
->cleanup_bh
);
269 s
->cleanup_bh
= NULL
;
272 DPRINTF("closing file\n");
273 qemu_fclose(s
->file
);
278 assert(s
->state
!= MIG_STATE_ACTIVE
);
280 if (s
->state
!= MIG_STATE_COMPLETED
) {
281 qemu_savevm_state_cancel();
284 notifier_list_notify(&migration_state_notifiers
, s
);
287 static void migrate_finish_set_state(MigrationState
*s
, int new_state
)
289 if (__sync_val_compare_and_swap(&s
->state
, MIG_STATE_ACTIVE
,
290 new_state
) == new_state
) {
291 trace_migrate_set_state(new_state
);
295 void migrate_fd_error(MigrationState
*s
)
297 DPRINTF("setting error state\n");
298 assert(s
->file
== NULL
);
299 s
->state
= MIG_STATE_ERROR
;
300 trace_migrate_set_state(MIG_STATE_ERROR
);
301 notifier_list_notify(&migration_state_notifiers
, 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
);
330 int migrate_fd_close(MigrationState
*s
)
340 void add_migration_state_change_notifier(Notifier
*notify
)
342 notifier_list_add(&migration_state_notifiers
, notify
);
345 void remove_migration_state_change_notifier(Notifier
*notify
)
347 notifier_remove(notify
);
350 bool migration_is_active(MigrationState
*s
)
352 return s
->state
== MIG_STATE_ACTIVE
;
355 bool migration_has_finished(MigrationState
*s
)
357 return s
->state
== MIG_STATE_COMPLETED
;
360 bool migration_has_failed(MigrationState
*s
)
362 return (s
->state
== MIG_STATE_CANCELLED
||
363 s
->state
== MIG_STATE_ERROR
);
366 static MigrationState
*migrate_init(const MigrationParams
*params
)
368 MigrationState
*s
= migrate_get_current();
369 int64_t bandwidth_limit
= s
->bandwidth_limit
;
370 bool enabled_capabilities
[MIGRATION_CAPABILITY_MAX
];
371 int64_t xbzrle_cache_size
= s
->xbzrle_cache_size
;
373 memcpy(enabled_capabilities
, s
->enabled_capabilities
,
374 sizeof(enabled_capabilities
));
376 memset(s
, 0, sizeof(*s
));
377 s
->bandwidth_limit
= bandwidth_limit
;
379 memcpy(s
->enabled_capabilities
, enabled_capabilities
,
380 sizeof(enabled_capabilities
));
381 s
->xbzrle_cache_size
= xbzrle_cache_size
;
383 s
->bandwidth_limit
= bandwidth_limit
;
384 s
->state
= MIG_STATE_SETUP
;
385 trace_migrate_set_state(MIG_STATE_SETUP
);
387 s
->total_time
= qemu_get_clock_ms(rt_clock
);
391 static GSList
*migration_blockers
;
393 void migrate_add_blocker(Error
*reason
)
395 migration_blockers
= g_slist_prepend(migration_blockers
, reason
);
398 void migrate_del_blocker(Error
*reason
)
400 migration_blockers
= g_slist_remove(migration_blockers
, reason
);
403 void qmp_migrate(const char *uri
, bool has_blk
, bool blk
,
404 bool has_inc
, bool inc
, bool has_detach
, bool detach
,
407 Error
*local_err
= NULL
;
408 MigrationState
*s
= migrate_get_current();
409 MigrationParams params
;
415 if (s
->state
== MIG_STATE_ACTIVE
) {
416 error_set(errp
, QERR_MIGRATION_ACTIVE
);
420 if (qemu_savevm_state_blocked(errp
)) {
424 if (migration_blockers
) {
425 *errp
= error_copy(migration_blockers
->data
);
429 s
= migrate_init(¶ms
);
431 if (strstart(uri
, "tcp:", &p
)) {
432 tcp_start_outgoing_migration(s
, p
, &local_err
);
434 } else if (strstart(uri
, "exec:", &p
)) {
435 exec_start_outgoing_migration(s
, p
, &local_err
);
436 } else if (strstart(uri
, "unix:", &p
)) {
437 unix_start_outgoing_migration(s
, p
, &local_err
);
438 } else if (strstart(uri
, "fd:", &p
)) {
439 fd_start_outgoing_migration(s
, p
, &local_err
);
442 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "uri", "a valid migration protocol");
448 error_propagate(errp
, local_err
);
453 void qmp_migrate_cancel(Error
**errp
)
455 migrate_fd_cancel(migrate_get_current());
458 void qmp_migrate_set_cache_size(int64_t value
, Error
**errp
)
460 MigrationState
*s
= migrate_get_current();
462 /* Check for truncation */
463 if (value
!= (size_t)value
) {
464 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cache size",
465 "exceeding address space");
469 s
->xbzrle_cache_size
= xbzrle_cache_resize(value
);
472 int64_t qmp_query_migrate_cache_size(Error
**errp
)
474 return migrate_xbzrle_cache_size();
477 void qmp_migrate_set_speed(int64_t value
, Error
**errp
)
485 s
= migrate_get_current();
486 s
->bandwidth_limit
= value
;
487 qemu_file_set_rate_limit(s
->file
, s
->bandwidth_limit
);
490 void qmp_migrate_set_downtime(double value
, Error
**errp
)
493 value
= MAX(0, MIN(UINT64_MAX
, value
));
494 max_downtime
= (uint64_t)value
;
497 int migrate_use_xbzrle(void)
501 s
= migrate_get_current();
503 return s
->enabled_capabilities
[MIGRATION_CAPABILITY_XBZRLE
];
506 int64_t migrate_xbzrle_cache_size(void)
510 s
= migrate_get_current();
512 return s
->xbzrle_cache_size
;
515 /* migration thread support */
518 static void buffered_flush(MigrationState
*s
)
523 DPRINTF("flushing %zu byte(s) of data\n", s
->buffer_size
);
525 if (qemu_file_get_error(s
->file
)) {
529 qemu_fflush(s
->file
);
531 while (s
->bytes_xfer
< s
->xfer_limit
&& offset
< s
->buffer_size
) {
532 size_t to_send
= MIN(s
->buffer_size
- offset
, s
->xfer_limit
- s
->bytes_xfer
);
533 ret
= migrate_fd_put_buffer(s
, s
->buffer
+ offset
, to_send
);
535 DPRINTF("error flushing data, %zd\n", ret
);
538 DPRINTF("flushed %zd byte(s)\n", ret
);
540 s
->bytes_xfer
+= ret
;
544 DPRINTF("flushed %zu of %zu byte(s)\n", offset
, s
->buffer_size
);
545 memmove(s
->buffer
, s
->buffer
+ offset
, s
->buffer_size
- offset
);
546 s
->buffer_size
-= offset
;
549 qemu_file_set_error(s
->file
, ret
);
553 static int buffered_put_buffer(void *opaque
, const uint8_t *buf
,
554 int64_t pos
, int size
)
556 MigrationState
*s
= opaque
;
559 DPRINTF("putting %d bytes at %" PRId64
"\n", size
, pos
);
561 error
= qemu_file_get_error(s
->file
);
563 DPRINTF("flush when error, bailing: %s\n", strerror(-error
));
571 if (size
> (s
->buffer_capacity
- s
->buffer_size
)) {
572 DPRINTF("increasing buffer capacity from %zu by %zu\n",
573 s
->buffer_capacity
, size
+ 1024);
575 s
->buffer_capacity
+= size
+ 1024;
577 s
->buffer
= g_realloc(s
->buffer
, s
->buffer_capacity
);
580 memcpy(s
->buffer
+ s
->buffer_size
, buf
, size
);
581 s
->buffer_size
+= size
;
586 static int buffered_close(void *opaque
)
588 MigrationState
*s
= opaque
;
590 DPRINTF("closing\n");
592 qemu_mutex_unlock_iothread();
593 qemu_thread_join(&s
->thread
);
594 qemu_mutex_lock_iothread();
595 assert(s
->state
!= MIG_STATE_ACTIVE
);
597 return migrate_fd_close(s
);
600 static int buffered_get_fd(void *opaque
)
602 MigrationState
*s
= opaque
;
608 * The meaning of the return values is:
609 * 0: We can continue sending
611 * negative: There has been an error
613 static int buffered_rate_limit(void *opaque
)
615 MigrationState
*s
= opaque
;
618 ret
= qemu_file_get_error(s
->file
);
623 if (s
->bytes_xfer
>= s
->xfer_limit
) {
630 static int64_t buffered_set_rate_limit(void *opaque
, int64_t new_rate
)
632 MigrationState
*s
= opaque
;
633 if (qemu_file_get_error(s
->file
)) {
636 if (new_rate
> SIZE_MAX
) {
640 s
->xfer_limit
= new_rate
/ XFER_LIMIT_RATIO
;
643 return s
->xfer_limit
;
646 static int64_t buffered_get_rate_limit(void *opaque
)
648 MigrationState
*s
= opaque
;
650 return s
->xfer_limit
;
653 static void *buffered_file_thread(void *opaque
)
655 MigrationState
*s
= opaque
;
656 int64_t initial_time
= qemu_get_clock_ms(rt_clock
);
657 int64_t sleep_time
= 0;
658 int64_t max_size
= 0;
659 int64_t start_time
= initial_time
;
660 bool old_vm_running
= false;
661 bool last_round
= false;
663 qemu_mutex_lock_iothread();
664 DPRINTF("beginning savevm\n");
665 qemu_savevm_state_begin(s
->file
, &s
->params
);
666 qemu_mutex_unlock_iothread();
668 while (s
->state
== MIG_STATE_ACTIVE
) {
669 int64_t current_time
;
670 uint64_t pending_size
;
672 if (s
->bytes_xfer
< s
->xfer_limit
) {
673 qemu_mutex_lock_iothread();
674 DPRINTF("iterate\n");
675 pending_size
= qemu_savevm_state_pending(s
->file
, max_size
);
676 DPRINTF("pending size %lu max %lu\n", pending_size
, max_size
);
677 if (pending_size
&& pending_size
>= max_size
) {
678 qemu_savevm_state_iterate(s
->file
);
680 DPRINTF("done iterating\n");
681 start_time
= qemu_get_clock_ms(rt_clock
);
682 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER
);
683 old_vm_running
= runstate_is_running();
684 vm_stop_force_state(RUN_STATE_FINISH_MIGRATE
);
685 s
->xfer_limit
= INT_MAX
;
686 qemu_savevm_state_complete(s
->file
);
689 qemu_mutex_unlock_iothread();
692 current_time
= qemu_get_clock_ms(rt_clock
);
693 if (current_time
>= initial_time
+ BUFFER_DELAY
) {
694 uint64_t transferred_bytes
= s
->bytes_xfer
;
695 uint64_t time_spent
= current_time
- initial_time
- sleep_time
;
696 double bandwidth
= transferred_bytes
/ time_spent
;
697 max_size
= bandwidth
* migrate_max_downtime() / 1000000;
699 DPRINTF("transferred %" PRIu64
" time_spent %" PRIu64
700 " bandwidth %g max_size %" PRId64
"\n",
701 transferred_bytes
, time_spent
, bandwidth
, max_size
);
702 /* if we haven't sent anything, we don't want to recalculate
703 10000 is a small enough number for our purposes */
704 if (s
->dirty_bytes_rate
&& transferred_bytes
> 10000) {
705 s
->expected_downtime
= s
->dirty_bytes_rate
/ bandwidth
;
710 initial_time
= current_time
;
712 if (!last_round
&& (s
->bytes_xfer
>= s
->xfer_limit
)) {
713 /* usleep expects microseconds */
714 g_usleep((initial_time
+ BUFFER_DELAY
- current_time
)*1000);
715 sleep_time
+= qemu_get_clock_ms(rt_clock
) - current_time
;
718 if (qemu_file_get_error(s
->file
)) {
719 migrate_finish_set_state(s
, MIG_STATE_ERROR
);
720 } else if (last_round
&& s
->buffer_size
== 0) {
721 migrate_finish_set_state(s
, MIG_STATE_COMPLETED
);
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_bh_schedule(s
->cleanup_bh
);
738 qemu_mutex_unlock_iothread();
744 static const QEMUFileOps buffered_file_ops
= {
745 .get_fd
= buffered_get_fd
,
746 .put_buffer
= buffered_put_buffer
,
747 .close
= buffered_close
,
748 .rate_limit
= buffered_rate_limit
,
749 .get_rate_limit
= buffered_get_rate_limit
,
750 .set_rate_limit
= buffered_set_rate_limit
,
753 void migrate_fd_connect(MigrationState
*s
)
755 s
->state
= MIG_STATE_ACTIVE
;
756 trace_migrate_set_state(MIG_STATE_ACTIVE
);
761 s
->buffer_capacity
= 0;
762 /* This is a best 1st approximation. ns to ms */
763 s
->expected_downtime
= max_downtime
/1000000;
765 s
->xfer_limit
= s
->bandwidth_limit
/ XFER_LIMIT_RATIO
;
767 s
->cleanup_bh
= qemu_bh_new(migrate_fd_cleanup
, s
);
768 s
->file
= qemu_fopen_ops(s
, &buffered_file_ops
);
770 qemu_thread_create(&s
->thread
, buffered_file_thread
, s
,
771 QEMU_THREAD_JOINABLE
);
772 notifier_list_notify(&migration_state_notifiers
, s
);