migration: new postcopy-pause state
[qemu.git] / migration / migration.h
blob26e5951d56e7f3c8e399ec725f45fd1fbad753fd
1 /*
2 * QEMU live migration
4 * Copyright IBM, Corp. 2008
6 * Authors:
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 "qemu-common.h"
18 #include "qapi/qapi-types-migration.h"
19 #include "qemu/thread.h"
20 #include "exec/cpu-common.h"
21 #include "qemu/coroutine_int.h"
22 #include "hw/qdev.h"
23 #include "io/channel.h"
25 struct PostcopyBlocktimeContext;
27 /* State for the incoming migration */
28 struct MigrationIncomingState {
29 QEMUFile *from_src_file;
32 * Free at the start of the main state load, set as the main thread finishes
33 * loading state.
35 QemuEvent main_thread_load_event;
37 size_t largest_page_size;
38 bool have_fault_thread;
39 QemuThread fault_thread;
40 QemuSemaphore fault_thread_sem;
41 /* Set this when we want the fault thread to quit */
42 bool fault_thread_quit;
44 bool have_listen_thread;
45 QemuThread listen_thread;
46 QemuSemaphore listen_thread_sem;
48 /* For the kernel to send us notifications */
49 int userfault_fd;
50 /* To notify the fault_thread to wake, e.g., when need to quit */
51 int userfault_event_fd;
52 QEMUFile *to_src_file;
53 QemuMutex rp_mutex; /* We send replies from multiple threads */
54 /* RAMBlock of last request sent to source */
55 RAMBlock *last_rb;
56 void *postcopy_tmp_page;
57 void *postcopy_tmp_zero_page;
58 /* PostCopyFD's for external userfaultfds & handlers of shared memory */
59 GArray *postcopy_remote_fds;
61 QEMUBH *bh;
63 int state;
65 bool have_colo_incoming_thread;
66 QemuThread colo_incoming_thread;
67 /* The coroutine we should enter (back) after failover */
68 Coroutine *migration_incoming_co;
69 QemuSemaphore colo_incoming_sem;
72 * PostcopyBlocktimeContext to keep information for postcopy
73 * live migration, to calculate vCPU block time
74 * */
75 struct PostcopyBlocktimeContext *blocktime_ctx;
78 MigrationIncomingState *migration_incoming_get_current(void);
79 void migration_incoming_state_destroy(void);
81 * Functions to work with blocktime context
83 void fill_destination_postcopy_migration_info(MigrationInfo *info);
85 #define TYPE_MIGRATION "migration"
87 #define MIGRATION_CLASS(klass) \
88 OBJECT_CLASS_CHECK(MigrationClass, (klass), TYPE_MIGRATION)
89 #define MIGRATION_OBJ(obj) \
90 OBJECT_CHECK(MigrationState, (obj), TYPE_MIGRATION)
91 #define MIGRATION_GET_CLASS(obj) \
92 OBJECT_GET_CLASS(MigrationClass, (obj), TYPE_MIGRATION)
94 typedef struct MigrationClass {
95 /*< private >*/
96 DeviceClass parent_class;
97 } MigrationClass;
99 struct MigrationState
101 /*< private >*/
102 DeviceState parent_obj;
104 /*< public >*/
105 size_t bytes_xfer;
106 size_t xfer_limit;
107 QemuThread thread;
108 QEMUBH *cleanup_bh;
109 QEMUFile *to_dst_file;
111 /* bytes already send at the beggining of current interation */
112 uint64_t iteration_initial_bytes;
113 /* time at the start of current iteration */
114 int64_t iteration_start_time;
116 * The final stage happens when the remaining data is smaller than
117 * this threshold; it's calculated from the requested downtime and
118 * measured bandwidth
120 int64_t threshold_size;
122 /* params from 'migrate-set-parameters' */
123 MigrationParameters parameters;
125 int state;
127 /* State related to return path */
128 struct {
129 QEMUFile *from_dst_file;
130 QemuThread rp_thread;
131 bool error;
132 } rp_state;
134 double mbps;
135 /* Timestamp when recent migration starts (ms) */
136 int64_t start_time;
137 /* Total time used by latest migration (ms) */
138 int64_t total_time;
139 /* Timestamp when VM is down (ms) to migrate the last stuff */
140 int64_t downtime_start;
141 int64_t downtime;
142 int64_t expected_downtime;
143 bool enabled_capabilities[MIGRATION_CAPABILITY__MAX];
144 int64_t setup_time;
146 * Whether guest was running when we enter the completion stage.
147 * If migration is interrupted by any reason, we need to continue
148 * running the guest on source.
150 bool vm_was_running;
152 /* Flag set once the migration has been asked to enter postcopy */
153 bool start_postcopy;
154 /* Flag set after postcopy has sent the device state */
155 bool postcopy_after_devices;
157 /* Flag set once the migration thread is running (and needs joining) */
158 bool migration_thread_running;
160 /* Flag set once the migration thread called bdrv_inactivate_all */
161 bool block_inactive;
163 /* Migration is paused due to pause-before-switchover */
164 QemuSemaphore pause_sem;
166 /* The semaphore is used to notify COLO thread that failover is finished */
167 QemuSemaphore colo_exit_sem;
169 /* The semaphore is used to notify COLO thread to do checkpoint */
170 QemuSemaphore colo_checkpoint_sem;
171 int64_t colo_checkpoint_time;
172 QEMUTimer *colo_delay_timer;
174 /* The first error that has occurred.
175 We used the mutex to be able to return the 1st error message */
176 Error *error;
177 /* mutex to protect errp */
178 QemuMutex error_mutex;
180 /* Do we have to clean up -b/-i from old migrate parameters */
181 /* This feature is deprecated and will be removed */
182 bool must_remove_block_options;
185 * Global switch on whether we need to store the global state
186 * during migration.
188 bool store_global_state;
190 /* Whether the VM is only allowing for migratable devices */
191 bool only_migratable;
193 /* Whether we send QEMU_VM_CONFIGURATION during migration */
194 bool send_configuration;
195 /* Whether we send section footer during migration */
196 bool send_section_footer;
199 void migrate_set_state(int *state, int old_state, int new_state);
201 void migration_fd_process_incoming(QEMUFile *f);
202 void migration_ioc_process_incoming(QIOChannel *ioc);
203 void migration_incoming_process(void);
205 bool migration_has_all_channels(void);
207 uint64_t migrate_max_downtime(void);
209 void migrate_set_error(MigrationState *s, const Error *error);
210 void migrate_fd_error(MigrationState *s, const Error *error);
212 void migrate_fd_connect(MigrationState *s, Error *error_in);
214 void migrate_init(MigrationState *s);
215 bool migration_is_blocked(Error **errp);
216 /* True if outgoing migration has entered postcopy phase */
217 bool migration_in_postcopy(void);
218 MigrationState *migrate_get_current(void);
220 bool migrate_postcopy(void);
222 bool migrate_release_ram(void);
223 bool migrate_postcopy_ram(void);
224 bool migrate_zero_blocks(void);
225 bool migrate_dirty_bitmaps(void);
227 bool migrate_auto_converge(void);
228 bool migrate_use_multifd(void);
229 bool migrate_pause_before_switchover(void);
230 int migrate_multifd_channels(void);
231 int migrate_multifd_page_count(void);
233 int migrate_use_xbzrle(void);
234 int64_t migrate_xbzrle_cache_size(void);
235 bool migrate_colo_enabled(void);
237 bool migrate_use_block(void);
238 bool migrate_use_block_incremental(void);
239 bool migrate_use_return_path(void);
241 bool migrate_use_compression(void);
242 int migrate_compress_level(void);
243 int migrate_compress_threads(void);
244 int migrate_decompress_threads(void);
245 bool migrate_use_events(void);
246 bool migrate_postcopy_blocktime(void);
248 /* Sending on the return path - generic and then for each message type */
249 void migrate_send_rp_shut(MigrationIncomingState *mis,
250 uint32_t value);
251 void migrate_send_rp_pong(MigrationIncomingState *mis,
252 uint32_t value);
253 int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char* rbname,
254 ram_addr_t start, size_t len);
256 void dirty_bitmap_mig_before_vm_start(void);
257 void init_dirty_bitmap_incoming_migration(void);
259 #endif