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