]>
Commit | Line | Data |
---|---|---|
5bb7910a AL |
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 | ||
d4842052 | 17 | #include "exec/cpu-common.h" |
a27bd6c7 | 18 | #include "hw/qdev-core.h" |
9af23989 | 19 | #include "qapi/qapi-types-migration.h" |
e3bf5e68 | 20 | #include "qapi/qmp/json-writer.h" |
9848a404 | 21 | #include "qemu/thread.h" |
25d0c16f | 22 | #include "qemu/coroutine_int.h" |
4f0fae7f | 23 | #include "io/channel.h" |
8518278a | 24 | #include "io/channel-buffer.h" |
7659505c | 25 | #include "net/announce.h" |
db1015e9 | 26 | #include "qom/object.h" |
36f62f11 | 27 | #include "postcopy-ram.h" |
f4584076 | 28 | #include "sysemu/runstate.h" |
376253ec | 29 | |
2a4c42f1 AP |
30 | struct PostcopyBlocktimeContext; |
31 | ||
13955b89 PX |
32 | #define MIGRATION_RESUME_ACK_VALUE (1) |
33 | ||
002cad6b PX |
34 | /* |
35 | * 1<<6=64 pages -> 256K chunk when page size is 4K. This gives us | |
36 | * the benefit that all the chunks are 64 pages aligned then the | |
37 | * bitmaps are always aligned to LONG. | |
38 | */ | |
39 | #define CLEAR_BITMAP_SHIFT_MIN 6 | |
40 | /* | |
41 | * 1<<18=256K pages -> 1G chunk when page size is 4K. This is the | |
42 | * default value to use if no one specified. | |
43 | */ | |
44 | #define CLEAR_BITMAP_SHIFT_DEFAULT 18 | |
45 | /* | |
46 | * 1<<31=2G pages -> 8T chunk when page size is 4K. This should be | |
47 | * big enough and make sure we won't overflow easily. | |
48 | */ | |
49 | #define CLEAR_BITMAP_SHIFT_MAX 31 | |
50 | ||
77dadc3f PX |
51 | /* This is an abstraction of a "temp huge page" for postcopy's purpose */ |
52 | typedef struct { | |
53 | /* | |
54 | * This points to a temporary huge page as a buffer for UFFDIO_COPY. It's | |
55 | * mmap()ed and needs to be freed when cleanup. | |
56 | */ | |
57 | void *tmp_huge_page; | |
58 | /* | |
59 | * This points to the host page we're going to install for this temp page. | |
60 | * It tells us after we've received the whole page, where we should put it. | |
61 | */ | |
62 | void *host_addr; | |
63 | /* Number of small pages copied (in size of TARGET_PAGE_SIZE) */ | |
64 | unsigned int target_pages; | |
65 | /* Whether this page contains all zeros */ | |
66 | bool all_zero; | |
67 | } PostcopyTmpPage; | |
68 | ||
6621883f PX |
69 | typedef enum { |
70 | PREEMPT_THREAD_NONE = 0, | |
71 | PREEMPT_THREAD_CREATED, | |
72 | PREEMPT_THREAD_QUIT, | |
73 | } PreemptThreadStatus; | |
74 | ||
bca7856a DDAG |
75 | /* State for the incoming migration */ |
76 | struct MigrationIncomingState { | |
42e2aa56 | 77 | QEMUFile *from_src_file; |
755e8d7c | 78 | /* Previously received RAM's RAMBlock pointer */ |
c01b16ed | 79 | RAMBlock *last_recv_block[RAM_CHANNEL_MAX]; |
1df6ddb4 DDAG |
80 | /* A hook to allow cleanup at the end of incoming migration */ |
81 | void *transport_data; | |
82 | void (*transport_cleanup)(void *data); | |
095c12a4 PX |
83 | /* |
84 | * Used to sync thread creations. Note that we can't create threads in | |
85 | * parallel with this sem. | |
86 | */ | |
87 | QemuSemaphore thread_sync_sem; | |
7b89bf27 DDAG |
88 | /* |
89 | * Free at the start of the main state load, set as the main thread finishes | |
90 | * loading state. | |
91 | */ | |
92 | QemuEvent main_thread_load_event; | |
93 | ||
7659505c DDAG |
94 | /* For network announces */ |
95 | AnnounceTimer announce_timer; | |
96 | ||
67f11b5c | 97 | size_t largest_page_size; |
c4faeed2 | 98 | bool have_fault_thread; |
f0a227ad | 99 | QemuThread fault_thread; |
64f615fe PX |
100 | /* Set this when we want the fault thread to quit */ |
101 | bool fault_thread_quit; | |
f0a227ad | 102 | |
c76201ab DDAG |
103 | bool have_listen_thread; |
104 | QemuThread listen_thread; | |
c76201ab | 105 | |
1caddf8a DDAG |
106 | /* For the kernel to send us notifications */ |
107 | int userfault_fd; | |
64f615fe PX |
108 | /* To notify the fault_thread to wake, e.g., when need to quit */ |
109 | int userfault_event_fd; | |
2e37701e | 110 | QEMUFile *to_src_file; |
6decec93 | 111 | QemuMutex rp_mutex; /* We send replies from multiple threads */ |
096bf4c8 DDAG |
112 | /* RAMBlock of last request sent to source */ |
113 | RAMBlock *last_rb; | |
77dadc3f PX |
114 | /* |
115 | * Number of postcopy channels including the default precopy channel, so | |
116 | * vanilla postcopy will only contain one channel which contain both | |
117 | * precopy and postcopy streams. | |
118 | * | |
119 | * This is calculated when the src requests to enable postcopy but before | |
120 | * it starts. Its value can depend on e.g. whether postcopy preemption is | |
121 | * enabled. | |
122 | */ | |
123 | unsigned int postcopy_channels; | |
36f62f11 PX |
124 | /* QEMUFile for postcopy only; it'll be handled by a separate thread */ |
125 | QEMUFile *postcopy_qemufile_dst; | |
5655aab0 PX |
126 | /* |
127 | * When postcopy_qemufile_dst is properly setup, this sem is posted. | |
128 | * One can wait on this semaphore to wait until the preempt channel is | |
129 | * properly setup. | |
130 | */ | |
131 | QemuSemaphore postcopy_qemufile_dst_done; | |
36f62f11 PX |
132 | /* Postcopy priority thread is used to receive postcopy requested pages */ |
133 | QemuThread postcopy_prio_thread; | |
6621883f PX |
134 | /* |
135 | * Always set by the main vm load thread only, but can be read by the | |
136 | * postcopy preempt thread. "volatile" makes sure all reads will be | |
d8b71d96 | 137 | * up-to-date across cores. |
6621883f PX |
138 | */ |
139 | volatile PreemptThreadStatus preempt_thread_status; | |
60bb3c58 PX |
140 | /* |
141 | * Used to sync between the ram load main thread and the fast ram load | |
142 | * thread. It protects postcopy_qemufile_dst, which is the postcopy | |
143 | * fast channel. | |
144 | * | |
145 | * The ram fast load thread will take it mostly for the whole lifecycle | |
146 | * because it needs to continuously read data from the channel, and | |
147 | * it'll only release this mutex if postcopy is interrupted, so that | |
148 | * the ram load main thread will take this mutex over and properly | |
149 | * release the broken channel. | |
150 | */ | |
151 | QemuMutex postcopy_prio_thread_mutex; | |
77dadc3f PX |
152 | /* |
153 | * An array of temp host huge pages to be used, one for each postcopy | |
154 | * channel. | |
155 | */ | |
156 | PostcopyTmpPage *postcopy_tmp_pages; | |
157 | /* This is shared for all postcopy channels */ | |
41d84210 | 158 | void *postcopy_tmp_zero_page; |
00fa4fc8 DDAG |
159 | /* PostCopyFD's for external userfaultfds & handlers of shared memory */ |
160 | GArray *postcopy_remote_fds; | |
2e37701e | 161 | |
0aa6aefc DL |
162 | QEMUBH *bh; |
163 | ||
93d7af6f | 164 | int state; |
25d0c16f | 165 | |
dd42ce24 VSO |
166 | /* |
167 | * The incoming migration coroutine, non-NULL during qemu_loadvm_state(). | |
168 | * Used to wake the migration incoming coroutine from rdma code. How much is | |
169 | * it safe - it's a question. | |
170 | */ | |
171 | Coroutine *loadvm_co; | |
172 | ||
25d0c16f | 173 | /* The coroutine we should enter (back) after failover */ |
dd42ce24 | 174 | Coroutine *colo_incoming_co; |
c937b9a6 | 175 | QemuSemaphore colo_incoming_sem; |
2a4c42f1 AP |
176 | |
177 | /* | |
178 | * PostcopyBlocktimeContext to keep information for postcopy | |
179 | * live migration, to calculate vCPU block time | |
180 | * */ | |
181 | struct PostcopyBlocktimeContext *blocktime_ctx; | |
b411b844 PX |
182 | |
183 | /* notify PAUSED postcopy incoming migrations to try to continue */ | |
184 | QemuSemaphore postcopy_pause_sem_dst; | |
3a7804c3 | 185 | QemuSemaphore postcopy_pause_sem_fault; |
60bb3c58 PX |
186 | /* |
187 | * This semaphore is used to allow the ram fast load thread (only when | |
188 | * postcopy preempt is enabled) fall into sleep when there's network | |
189 | * interruption detected. When the recovery is done, the main load | |
190 | * thread will kick the fast ram load thread using this semaphore. | |
191 | */ | |
192 | QemuSemaphore postcopy_pause_sem_fast_load; | |
9aca82ba JQ |
193 | |
194 | /* List of listening socket addresses */ | |
195 | SocketAddressList *socket_address_list; | |
8f8bfffc PX |
196 | |
197 | /* A tree of pages that we requested to the source VM */ | |
198 | GTree *page_requested; | |
cf02f29e PX |
199 | /* |
200 | * For postcopy only, count the number of requested page faults that | |
201 | * still haven't been resolved. | |
202 | */ | |
8f8bfffc PX |
203 | int page_requested_count; |
204 | /* | |
205 | * The mutex helps to maintain the requested pages that we sent to the | |
206 | * source, IOW, to guarantee coherent between the page_requests tree and | |
207 | * the per-ramblock receivedmap. Note! This does not guarantee consistency | |
208 | * of the real page copy procedures (using UFFDIO_[ZERO]COPY). E.g., even | |
209 | * if one bit in receivedmap is cleared, UFFDIO_COPY could have happened | |
210 | * for that page already. This is intended so that the mutex won't | |
211 | * serialize and blocked by slow operations like UFFDIO_* ioctls. However | |
212 | * this should be enough to make sure the page_requested tree always | |
213 | * contains valid information. | |
214 | */ | |
215 | QemuMutex page_request_mutex; | |
cf02f29e PX |
216 | /* |
217 | * If postcopy preempt is enabled, there is a chance that the main | |
218 | * thread finished loading its data before the preempt channel has | |
219 | * finished loading the urgent pages. If that happens, the two threads | |
220 | * will use this condvar to synchronize, so the main thread will always | |
221 | * wait until all pages received. | |
222 | */ | |
223 | QemuCond page_request_cond; | |
1b4adb10 AH |
224 | |
225 | /* | |
226 | * Number of devices that have yet to approve switchover. When this reaches | |
227 | * zero an ACK that it's OK to do switchover is sent to the source. No lock | |
228 | * is needed as this field is updated serially. | |
229 | */ | |
230 | unsigned int switchover_ack_pending_num; | |
bca7856a DDAG |
231 | }; |
232 | ||
233 | MigrationIncomingState *migration_incoming_get_current(void); | |
bca7856a | 234 | void migration_incoming_state_destroy(void); |
e031149c | 235 | void migration_incoming_transport_cleanup(MigrationIncomingState *mis); |
65ace060 AP |
236 | /* |
237 | * Functions to work with blocktime context | |
238 | */ | |
239 | void fill_destination_postcopy_migration_info(MigrationInfo *info); | |
bca7856a | 240 | |
e5cb7e76 PX |
241 | #define TYPE_MIGRATION "migration" |
242 | ||
db1015e9 | 243 | typedef struct MigrationClass MigrationClass; |
8110fa1d EH |
244 | DECLARE_OBJ_CHECKERS(MigrationState, MigrationClass, |
245 | MIGRATION_OBJ, TYPE_MIGRATION) | |
e5cb7e76 | 246 | |
db1015e9 | 247 | struct MigrationClass { |
e5cb7e76 PX |
248 | /*< private >*/ |
249 | DeviceClass parent_class; | |
db1015e9 | 250 | }; |
e5cb7e76 | 251 | |
f16aee44 | 252 | struct MigrationState { |
e5cb7e76 PX |
253 | /*< private >*/ |
254 | DeviceState parent_obj; | |
255 | ||
256 | /*< public >*/ | |
9848a404 | 257 | QemuThread thread; |
8518278a | 258 | QEMUBH *vm_start_bh; |
bb1fadc4 | 259 | QEMUBH *cleanup_bh; |
43044ac0 | 260 | /* Protected by qemu_file_lock */ |
89a02a9f | 261 | QEMUFile *to_dst_file; |
36f62f11 PX |
262 | /* Postcopy specific transfer channel */ |
263 | QEMUFile *postcopy_qemufile_src; | |
d0edb8a1 PX |
264 | /* |
265 | * It is posted when the preempt channel is established. Note: this is | |
266 | * used for both the start or recover of a postcopy migration. We'll | |
267 | * post to this sem every time a new preempt channel is created in the | |
268 | * main thread, and we keep post() and wait() in pair. | |
269 | */ | |
270 | QemuSemaphore postcopy_qemufile_src_sem; | |
8518278a | 271 | QIOChannelBuffer *bioc; |
62df066f | 272 | /* |
43044ac0 PX |
273 | * Protects to_dst_file/from_dst_file pointers. We need to make sure we |
274 | * won't yield or hang during the critical section, since this lock will be | |
275 | * used in OOB command handler. | |
62df066f PX |
276 | */ |
277 | QemuMutex qemu_file_lock; | |
2594f56d | 278 | |
ad767bed DDAG |
279 | /* |
280 | * Used to allow urgent requests to override rate limiting. | |
281 | */ | |
282 | QemuSemaphore rate_limit_sem; | |
283 | ||
aecbfe9c XG |
284 | /* pages already send at the beginning of current iteration */ |
285 | uint64_t iteration_initial_pages; | |
286 | ||
287 | /* pages transferred per second */ | |
288 | double pages_per_second; | |
289 | ||
290 | /* bytes already send at the beginning of current iteration */ | |
b15df1ae PX |
291 | uint64_t iteration_initial_bytes; |
292 | /* time at the start of current iteration */ | |
293 | int64_t iteration_start_time; | |
294 | /* | |
295 | * The final stage happens when the remaining data is smaller than | |
296 | * this threshold; it's calculated from the requested downtime and | |
297 | * measured bandwidth | |
298 | */ | |
299 | int64_t threshold_size; | |
300 | ||
a0762d9e | 301 | /* params from 'migrate-set-parameters' */ |
2594f56d | 302 | MigrationParameters parameters; |
f8bbc128 | 303 | |
f8bbc128 | 304 | int state; |
70b20477 DDAG |
305 | |
306 | /* State related to return path */ | |
307 | struct { | |
43044ac0 | 308 | /* Protected by qemu_file_lock */ |
70b20477 DDAG |
309 | QEMUFile *from_dst_file; |
310 | QemuThread rp_thread; | |
311 | bool error; | |
53021ea1 PX |
312 | /* |
313 | * We can also check non-zero of rp_thread, but there's no "official" | |
314 | * way to do this, so this bool makes it slightly more elegant. | |
315 | * Checking from_dst_file for this is racy because from_dst_file will | |
316 | * be cleared in the rp_thread! | |
317 | */ | |
318 | bool rp_thread_created; | |
edd090c7 | 319 | QemuSemaphore rp_sem; |
b28fb582 PX |
320 | /* |
321 | * We post to this when we got one PONG from dest. So far it's an | |
322 | * easy way to know the main channel has successfully established | |
323 | * on dest QEMU. | |
324 | */ | |
325 | QemuSemaphore rp_pong_acks; | |
70b20477 DDAG |
326 | } rp_state; |
327 | ||
7e114f8c | 328 | double mbps; |
4af246a3 PX |
329 | /* Timestamp when recent migration starts (ms) */ |
330 | int64_t start_time; | |
331 | /* Total time used by latest migration (ms) */ | |
d5f8a570 | 332 | int64_t total_time; |
64909f97 PX |
333 | /* Timestamp when VM is down (ms) to migrate the last stuff */ |
334 | int64_t downtime_start; | |
9c5a9fcf | 335 | int64_t downtime; |
2c52ddf1 | 336 | int64_t expected_downtime; |
0cec2056 | 337 | bool capabilities[MIGRATION_CAPABILITY__MAX]; |
ed4fbd10 | 338 | int64_t setup_time; |
f4584076 | 339 | |
7287cbd4 | 340 | /* |
f4584076 | 341 | * State before stopping the vm by vm_stop_force_state(). |
7287cbd4 | 342 | * If migration is interrupted by any reason, we need to continue |
f4584076 VSO |
343 | * running the guest on source if it was running or restore its stopped |
344 | * state. | |
7287cbd4 | 345 | */ |
f4584076 | 346 | RunState vm_old_state; |
4886a1bc DDAG |
347 | |
348 | /* Flag set once the migration has been asked to enter postcopy */ | |
349 | bool start_postcopy; | |
b82fc321 DDAG |
350 | /* Flag set after postcopy has sent the device state */ |
351 | bool postcopy_after_devices; | |
1d34e4bf DDAG |
352 | |
353 | /* Flag set once the migration thread is running (and needs joining) */ | |
354 | bool migration_thread_running; | |
6c595cde | 355 | |
1d2acc31 HZ |
356 | /* Flag set once the migration thread called bdrv_inactivate_all */ |
357 | bool block_inactive; | |
358 | ||
c7e0acd5 JF |
359 | /* Migration is waiting for guest to unplug device */ |
360 | QemuSemaphore wait_unplug_sem; | |
361 | ||
e91d8951 DDAG |
362 | /* Migration is paused due to pause-before-switchover */ |
363 | QemuSemaphore pause_sem; | |
364 | ||
c937b9a6 HZ |
365 | /* The semaphore is used to notify COLO thread that failover is finished */ |
366 | QemuSemaphore colo_exit_sem; | |
d59ce6f3 | 367 | |
bb70b66e LS |
368 | /* The event is used to notify COLO thread to do checkpoint */ |
369 | QemuEvent colo_checkpoint_event; | |
479125d5 HZ |
370 | int64_t colo_checkpoint_time; |
371 | QEMUTimer *colo_delay_timer; | |
372 | ||
87db1a7d JQ |
373 | /* The first error that has occurred. |
374 | We used the mutex to be able to return the 1st error message */ | |
d59ce6f3 | 375 | Error *error; |
87db1a7d JQ |
376 | /* mutex to protect errp */ |
377 | QemuMutex error_mutex; | |
378 | ||
2833c59b JQ |
379 | /* Do we have to clean up -b/-i from old migrate parameters */ |
380 | /* This feature is deprecated and will be removed */ | |
381 | bool must_remove_block_options; | |
5272298c PX |
382 | |
383 | /* | |
384 | * Global switch on whether we need to store the global state | |
385 | * during migration. | |
386 | */ | |
387 | bool store_global_state; | |
3df663e5 | 388 | |
71dd4c1a PX |
389 | /* Whether we send QEMU_VM_CONFIGURATION during migration */ |
390 | bool send_configuration; | |
15c38503 PX |
391 | /* Whether we send section footer during migration */ |
392 | bool send_section_footer; | |
b23c2ade PX |
393 | |
394 | /* Needed by postcopy-pause state */ | |
395 | QemuSemaphore postcopy_pause_sem; | |
f548222c XG |
396 | /* |
397 | * Whether we abort the migration if decompression errors are | |
398 | * detected at the destination. It is left at false for qemu | |
399 | * older than 3.0, since only newer qemu sends streams that | |
400 | * do not trigger spurious decompression errors. | |
401 | */ | |
402 | bool decompress_error_check; | |
6621883f PX |
403 | /* |
404 | * This variable only affects behavior when postcopy preempt mode is | |
405 | * enabled. | |
406 | * | |
407 | * When set: | |
408 | * | |
409 | * - postcopy preempt src QEMU instance will generate an EOS message at | |
410 | * the end of migration to shut the preempt channel on dest side. | |
411 | * | |
06064a67 PX |
412 | * - postcopy preempt channel will be created at the setup phase on src |
413 | QEMU. | |
414 | * | |
6621883f PX |
415 | * When clear: |
416 | * | |
417 | * - postcopy preempt src QEMU instance will _not_ generate an EOS | |
418 | * message at the end of migration, the dest qemu will shutdown the | |
419 | * channel itself. | |
420 | * | |
06064a67 | 421 | * - postcopy preempt channel will be created at the switching phase |
d8b71d96 | 422 | * from precopy -> postcopy (to avoid race condition of misordered |
06064a67 PX |
423 | * creation of channels). |
424 | * | |
6621883f PX |
425 | * NOTE: See message-id <ZBoShWArKDPpX/D7@work-vm> on qemu-devel |
426 | * mailing list for more information on the possible race. Everyone | |
427 | * should probably just keep this value untouched after set by the | |
428 | * machine type (or the default). | |
429 | */ | |
430 | bool preempt_pre_7_2; | |
002cad6b | 431 | |
77c259a4 JQ |
432 | /* |
433 | * flush every channel after each section sent. | |
434 | * | |
435 | * This assures that we can't mix pages from one iteration through | |
436 | * ram pages with pages for the following iteration. We really | |
437 | * only need to do this flush after we have go through all the | |
438 | * dirty pages. For historical reasons, we do that after each | |
439 | * section. This is suboptimal (we flush too many times). | |
294e5a40 | 440 | * Default value is false. (since 8.1) |
77c259a4 JQ |
441 | */ |
442 | bool multifd_flush_after_each_section; | |
002cad6b PX |
443 | /* |
444 | * This decides the size of guest memory chunk that will be used | |
445 | * to track dirty bitmap clearing. The size of memory chunk will | |
446 | * be GUEST_PAGE_SIZE << N. Say, N=0 means we will clear dirty | |
447 | * bitmap for each page to send (1<<0=1); N=10 means we will clear | |
448 | * dirty bitmap only once for 1<<10=1K continuous guest pages | |
449 | * (which is in 4M chunk). | |
450 | */ | |
451 | uint8_t clear_bitmap_shift; | |
d8053e73 CZ |
452 | |
453 | /* | |
454 | * This save hostname when out-going migration starts | |
455 | */ | |
456 | char *hostname; | |
e3bf5e68 DH |
457 | |
458 | /* QEMU_VM_VMDESCRIPTION content filled for all non-iterable devices. */ | |
459 | JSONWriter *vmdesc; | |
1b4adb10 AH |
460 | |
461 | /* | |
462 | * Indicates whether an ACK from the destination that it's OK to do | |
463 | * switchover has been received. | |
464 | */ | |
465 | bool switchover_acked; | |
065e2813 AL |
466 | }; |
467 | ||
48781e5b HZ |
468 | void migrate_set_state(int *state, int old_state, int new_state); |
469 | ||
b673eab4 | 470 | void migration_fd_process_incoming(QEMUFile *f, Error **errp); |
49ed0d24 | 471 | void migration_ioc_process_incoming(QIOChannel *ioc, Error **errp); |
36c2f8be | 472 | void migration_incoming_process(void); |
511c0231 | 473 | |
428d8908 JQ |
474 | bool migration_has_all_channels(void); |
475 | ||
a0a3fd60 GC |
476 | uint64_t migrate_max_downtime(void); |
477 | ||
87db1a7d | 478 | void migrate_set_error(MigrationState *s, const Error *error); |
065e2813 | 479 | |
cce8040b | 480 | void migrate_fd_connect(MigrationState *s, Error *error_in); |
065e2813 | 481 | |
3d63da16 | 482 | bool migration_is_setup_or_active(int state); |
392d87e2 | 483 | bool migration_is_running(int state); |
3d63da16 | 484 | |
08fc4cb5 | 485 | int migrate_init(MigrationState *s, Error **errp); |
24f3902b | 486 | bool migration_is_blocked(Error **errp); |
9ec055ae | 487 | /* True if outgoing migration has entered postcopy phase */ |
5727309d | 488 | bool migration_in_postcopy(void); |
859bc756 | 489 | MigrationState *migrate_get_current(void); |
99a0db9b | 490 | |
aecbfe9c XG |
491 | uint64_t ram_get_total_transferred_pages(void); |
492 | ||
6decec93 | 493 | /* Sending on the return path - generic and then for each message type */ |
6decec93 DDAG |
494 | void migrate_send_rp_shut(MigrationIncomingState *mis, |
495 | uint32_t value); | |
496 | void migrate_send_rp_pong(MigrationIncomingState *mis, | |
497 | uint32_t value); | |
2e2bce16 | 498 | int migrate_send_rp_req_pages(MigrationIncomingState *mis, RAMBlock *rb, |
8f8bfffc | 499 | ram_addr_t start, uint64_t haddr); |
7a267fc4 PX |
500 | int migrate_send_rp_message_req_pages(MigrationIncomingState *mis, |
501 | RAMBlock *rb, ram_addr_t start); | |
a335debb PX |
502 | void migrate_send_rp_recv_bitmap(MigrationIncomingState *mis, |
503 | char *block_name); | |
13955b89 | 504 | void migrate_send_rp_resume_ack(MigrationIncomingState *mis, uint32_t value); |
1b4adb10 | 505 | int migrate_send_rp_switchover_ack(MigrationIncomingState *mis); |
6decec93 | 506 | |
b35ebdf0 | 507 | void dirty_bitmap_mig_before_vm_start(void); |
1499ab09 VSO |
508 | void dirty_bitmap_mig_cancel_outgoing(void); |
509 | void dirty_bitmap_mig_cancel_incoming(void); | |
31e4c354 HR |
510 | bool check_dirty_bitmap_mig_alias_map(const BitmapMigrationNodeAliasList *bbm, |
511 | Error **errp); | |
512 | ||
9aca82ba | 513 | void migrate_add_address(SocketAddress *address); |
b35ebdf0 | 514 | |
fbd162e6 YK |
515 | int foreach_not_ignored_block(RAMBlockIterFunc func, void *opaque); |
516 | ||
343f632c | 517 | #define qemu_ram_foreach_block \ |
fbd162e6 | 518 | #warning "Use foreach_not_ignored_block in migration code" |
343f632c | 519 | |
ad767bed DDAG |
520 | void migration_make_urgent_request(void); |
521 | void migration_consume_urgent_request(void); | |
97e1e067 | 522 | bool migration_rate_limit(void); |
458fecca | 523 | void migration_cancel(const Error *error); |
ad767bed | 524 | |
38c482b4 AH |
525 | void migration_populate_vfio_info(MigrationInfo *info); |
526 | void migration_reset_vfio_bytes_transferred(void); | |
77dadc3f | 527 | void postcopy_temp_page_reset(PostcopyTmpPage *tmp_page); |
43bd0bf3 | 528 | |
5bb7910a | 529 | #endif |