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 #ifndef QEMU_MIGRATION_H
15 #define QEMU_MIGRATION_H
17 #include "qapi/qmp/qdict.h"
18 #include "qemu-common.h"
19 #include "qemu/thread.h"
20 #include "qemu/notify.h"
21 #include "migration/vmstate.h"
22 #include "qapi-types.h"
23 #include "exec/cpu-common.h"
25 #define QEMU_VM_FILE_MAGIC 0x5145564d
26 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
27 #define QEMU_VM_FILE_VERSION 0x00000003
29 #define QEMU_VM_EOF 0x00
30 #define QEMU_VM_SECTION_START 0x01
31 #define QEMU_VM_SECTION_PART 0x02
32 #define QEMU_VM_SECTION_END 0x03
33 #define QEMU_VM_SECTION_FULL 0x04
34 #define QEMU_VM_SUBSECTION 0x05
35 #define QEMU_VM_VMDESCRIPTION 0x06
36 #define QEMU_VM_CONFIGURATION 0x07
37 #define QEMU_VM_COMMAND 0x08
38 #define QEMU_VM_SECTION_FOOTER 0x7e
40 struct MigrationParams
{
45 /* Messages sent on the return path from destination to source */
46 enum mig_rp_message_type
{
47 MIG_RP_MSG_INVALID
= 0, /* Must be 0 */
48 MIG_RP_MSG_SHUT
, /* sibling will not send any more RP messages */
49 MIG_RP_MSG_PONG
, /* Response to a PING; data (seq: be32 ) */
51 MIG_RP_MSG_REQ_PAGES_ID
, /* data (start: be64, len: be32, id: string) */
52 MIG_RP_MSG_REQ_PAGES
, /* data (start: be64, len: be32) */
57 typedef QLIST_HEAD(, LoadStateEntry
) LoadStateEntry_Head
;
59 /* The current postcopy state is read/set by postcopy_state_get/set
60 * which update it atomically.
61 * The state is updated as postcopy messages are received, and
62 * in general only one thread should be writing to the state at any one
63 * time, initially the main thread and then the listen thread;
64 * Corner cases are where either thread finishes early and/or errors.
65 * The state is checked as messages are received to ensure that
66 * the source is sending us messages in the correct order.
67 * The state is also used by the RAM reception code to know if it
68 * has to place pages atomically, and the cleanup code at the end of
69 * the main thread to know if it has to delay cleanup until the end
73 POSTCOPY_INCOMING_NONE
= 0, /* Initial state - no postcopy */
74 POSTCOPY_INCOMING_ADVISE
,
75 POSTCOPY_INCOMING_DISCARD
,
76 POSTCOPY_INCOMING_LISTENING
,
77 POSTCOPY_INCOMING_RUNNING
,
81 /* State for the incoming migration */
82 struct MigrationIncomingState
{
83 QEMUFile
*from_src_file
;
86 * Free at the start of the main state load, set as the main thread finishes
89 QemuEvent main_thread_load_event
;
91 bool have_fault_thread
;
92 QemuThread fault_thread
;
93 QemuSemaphore fault_thread_sem
;
95 bool have_listen_thread
;
96 QemuThread listen_thread
;
97 QemuSemaphore listen_thread_sem
;
99 /* For the kernel to send us notifications */
101 /* To tell the fault_thread to quit */
102 int userfault_quit_fd
;
103 QEMUFile
*to_src_file
;
104 QemuMutex rp_mutex
; /* We send replies from multiple threads */
105 void *postcopy_tmp_page
;
111 LoadStateEntry_Head loadvm_handlers
;
114 MigrationIncomingState
*migration_incoming_get_current(void);
115 MigrationIncomingState
*migration_incoming_state_new(QEMUFile
*f
);
116 void migration_incoming_state_destroy(void);
119 * An outstanding page request, on the source, having been received
122 struct MigrationSrcPageRequest
{
127 QSIMPLEQ_ENTRY(MigrationSrcPageRequest
) next_req
;
130 struct MigrationState
132 int64_t bandwidth_limit
;
137 QEMUFile
*to_dst_file
;
138 int parameters
[MIGRATION_PARAMETER__MAX
];
141 MigrationParams params
;
143 /* State related to return path */
145 QEMUFile
*from_dst_file
;
146 QemuThread rp_thread
;
153 int64_t expected_downtime
;
154 int64_t dirty_pages_rate
;
155 int64_t dirty_bytes_rate
;
156 bool enabled_capabilities
[MIGRATION_CAPABILITY__MAX
];
157 int64_t xbzrle_cache_size
;
159 int64_t dirty_sync_count
;
161 /* Flag set once the migration has been asked to enter postcopy */
163 /* Flag set after postcopy has sent the device state */
164 bool postcopy_after_devices
;
166 /* Flag set once the migration thread is running (and needs joining) */
167 bool migration_thread_running
;
169 /* Queue of outstanding page requests from the destination */
170 QemuMutex src_page_req_mutex
;
171 QSIMPLEQ_HEAD(src_page_requests
, MigrationSrcPageRequest
) src_page_requests
;
172 /* The RAMBlock used in the last src_page_request */
173 RAMBlock
*last_req_rb
;
175 /* The last error that occurred */
179 void migrate_set_state(int *state
, int old_state
, int new_state
);
181 void process_incoming_migration(QEMUFile
*f
);
183 void qemu_start_incoming_migration(const char *uri
, Error
**errp
);
185 void migration_set_incoming_channel(MigrationState
*s
,
188 void migration_set_outgoing_channel(MigrationState
*s
,
191 uint64_t migrate_max_downtime(void);
193 void exec_start_incoming_migration(const char *host_port
, Error
**errp
);
195 void exec_start_outgoing_migration(MigrationState
*s
, const char *host_port
, Error
**errp
);
197 void tcp_start_incoming_migration(const char *host_port
, Error
**errp
);
199 void tcp_start_outgoing_migration(MigrationState
*s
, const char *host_port
, Error
**errp
);
201 void unix_start_incoming_migration(const char *path
, Error
**errp
);
203 void unix_start_outgoing_migration(MigrationState
*s
, const char *path
, Error
**errp
);
205 void fd_start_incoming_migration(const char *path
, Error
**errp
);
207 void fd_start_outgoing_migration(MigrationState
*s
, const char *fdname
, Error
**errp
);
209 void rdma_start_outgoing_migration(void *opaque
, const char *host_port
, Error
**errp
);
211 void rdma_start_incoming_migration(const char *host_port
, Error
**errp
);
213 void migrate_fd_error(MigrationState
*s
, const Error
*error
);
215 void migrate_fd_connect(MigrationState
*s
);
217 int migrate_fd_close(MigrationState
*s
);
219 void add_migration_state_change_notifier(Notifier
*notify
);
220 void remove_migration_state_change_notifier(Notifier
*notify
);
221 MigrationState
*migrate_init(const MigrationParams
*params
);
222 bool migration_is_blocked(Error
**errp
);
223 bool migration_in_setup(MigrationState
*);
224 bool migration_has_finished(MigrationState
*);
225 bool migration_has_failed(MigrationState
*);
226 /* True if outgoing migration has entered postcopy phase */
227 bool migration_in_postcopy(MigrationState
*);
228 /* ...and after the device transmission */
229 bool migration_in_postcopy_after_devices(MigrationState
*);
230 MigrationState
*migrate_get_current(void);
232 void migrate_compress_threads_create(void);
233 void migrate_compress_threads_join(void);
234 void migrate_decompress_threads_create(void);
235 void migrate_decompress_threads_join(void);
236 uint64_t ram_bytes_remaining(void);
237 uint64_t ram_bytes_transferred(void);
238 uint64_t ram_bytes_total(void);
239 void free_xbzrle_decoded_buf(void);
241 void acct_update_position(QEMUFile
*f
, size_t size
, bool zero
);
243 uint64_t dup_mig_bytes_transferred(void);
244 uint64_t dup_mig_pages_transferred(void);
245 uint64_t skipped_mig_bytes_transferred(void);
246 uint64_t skipped_mig_pages_transferred(void);
247 uint64_t norm_mig_bytes_transferred(void);
248 uint64_t norm_mig_pages_transferred(void);
249 uint64_t xbzrle_mig_bytes_transferred(void);
250 uint64_t xbzrle_mig_pages_transferred(void);
251 uint64_t xbzrle_mig_pages_overflow(void);
252 uint64_t xbzrle_mig_pages_cache_miss(void);
253 double xbzrle_mig_cache_miss_rate(void);
255 void ram_handle_compressed(void *host
, uint8_t ch
, uint64_t size
);
256 void ram_debug_dump_bitmap(unsigned long *todump
, bool expected
);
257 /* For outgoing discard bitmap */
258 int ram_postcopy_send_discard_bitmap(MigrationState
*ms
);
259 /* For incoming postcopy discard */
260 int ram_discard_range(MigrationIncomingState
*mis
, const char *block_name
,
261 uint64_t start
, size_t length
);
262 int ram_postcopy_incoming_init(MigrationIncomingState
*mis
);
265 * @migrate_add_blocker - prevent migration from proceeding
267 * @reason - an error to be returned whenever migration is attempted
269 void migrate_add_blocker(Error
*reason
);
272 * @migrate_del_blocker - remove a blocking error from migration
274 * @reason - the error blocking migration
276 void migrate_del_blocker(Error
*reason
);
278 bool migrate_postcopy_ram(void);
279 bool migrate_zero_blocks(void);
281 bool migrate_auto_converge(void);
283 int xbzrle_encode_buffer(uint8_t *old_buf
, uint8_t *new_buf
, int slen
,
284 uint8_t *dst
, int dlen
);
285 int xbzrle_decode_buffer(uint8_t *src
, int slen
, uint8_t *dst
, int dlen
);
287 int migrate_use_xbzrle(void);
288 int64_t migrate_xbzrle_cache_size(void);
290 int64_t xbzrle_cache_resize(int64_t new_size
);
292 bool migrate_use_compression(void);
293 int migrate_compress_level(void);
294 int migrate_compress_threads(void);
295 int migrate_decompress_threads(void);
296 bool migrate_use_events(void);
298 /* Sending on the return path - generic and then for each message type */
299 void migrate_send_rp_message(MigrationIncomingState
*mis
,
300 enum mig_rp_message_type message_type
,
301 uint16_t len
, void *data
);
302 void migrate_send_rp_shut(MigrationIncomingState
*mis
,
304 void migrate_send_rp_pong(MigrationIncomingState
*mis
,
306 void migrate_send_rp_req_pages(MigrationIncomingState
*mis
, const char* rbname
,
307 ram_addr_t start
, size_t len
);
309 void ram_control_before_iterate(QEMUFile
*f
, uint64_t flags
);
310 void ram_control_after_iterate(QEMUFile
*f
, uint64_t flags
);
311 void ram_control_load_hook(QEMUFile
*f
, uint64_t flags
, void *data
);
313 /* Whenever this is found in the data stream, the flags
314 * will be passed to ram_control_load_hook in the incoming-migration
315 * side. This lets before_ram_iterate/after_ram_iterate add
316 * transport-specific sections to the RAM migration data.
318 #define RAM_SAVE_FLAG_HOOK 0x80
320 #define RAM_SAVE_CONTROL_NOT_SUPP -1000
321 #define RAM_SAVE_CONTROL_DELAYED -2000
323 size_t ram_control_save_page(QEMUFile
*f
, ram_addr_t block_offset
,
324 ram_addr_t offset
, size_t size
,
325 uint64_t *bytes_sent
);
327 void ram_mig_init(void);
328 void savevm_skip_section_footers(void);
329 void register_global_state(void);
330 void global_state_set_optional(void);
331 void savevm_skip_configuration(void);
332 int global_state_store(void);
333 void global_state_store_running(void);
335 void flush_page_queue(MigrationState
*ms
);
336 int ram_save_queue_pages(MigrationState
*ms
, const char *rbname
,
337 ram_addr_t start
, ram_addr_t len
);
339 PostcopyState
postcopy_state_get(void);
340 /* Set the state and return the old state */
341 PostcopyState
postcopy_state_set(PostcopyState new_state
);