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 "exec/cpu-common.h" 18 #include "hw/qdev-core.h" 19 #include "qapi/qapi-types-migration.h" 20 #include "qapi/qmp/json-writer.h" 21 #include "qemu/thread.h" 22 #include "qemu/coroutine_int.h" 23 #include "io/channel.h" 24 #include "io/channel-buffer.h" 25 #include "net/announce.h" 26 #include "qom/object.h" 27 #include "postcopy-ram.h" 28 #include "sysemu/runstate.h" 29 30 struct PostcopyBlocktimeContext; 31 32 #define MIGRATION_RESUME_ACK_VALUE (1) 33 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 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 69 typedef enum { 70 PREEMPT_THREAD_NONE = 0, 71 PREEMPT_THREAD_CREATED, 72 PREEMPT_THREAD_QUIT, 73 } PreemptThreadStatus; 74 75 /* State for the incoming migration */ 76 struct MigrationIncomingState { 77 QEMUFile *from_src_file; 78 /* Previously received RAM's RAMBlock pointer */ 79 RAMBlock *last_recv_block[RAM_CHANNEL_MAX]; 80 /* A hook to allow cleanup at the end of incoming migration */ 81 void *transport_data; 82 void (*transport_cleanup)(void *data); 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; 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 94 /* For network announces */ 95 AnnounceTimer announce_timer; 96 97 size_t largest_page_size; 98 bool have_fault_thread; 99 QemuThread fault_thread; 100 /* Set this when we want the fault thread to quit */ 101 bool fault_thread_quit; 102 103 bool have_listen_thread; 104 QemuThread listen_thread; 105 106 /* For the kernel to send us notifications */ 107 int userfault_fd; 108 /* To notify the fault_thread to wake, e.g., when need to quit */ 109 int userfault_event_fd; 110 QEMUFile *to_src_file; 111 QemuMutex rp_mutex; /* We send replies from multiple threads */ 112 /* RAMBlock of last request sent to source */ 113 RAMBlock *last_rb; 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; 124 /* QEMUFile for postcopy only; it'll be handled by a separate thread */ 125 QEMUFile *postcopy_qemufile_dst; 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; 132 /* Postcopy priority thread is used to receive postcopy requested pages */ 133 QemuThread postcopy_prio_thread; 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 137 * up-to-date across cores. 138 */ 139 volatile PreemptThreadStatus preempt_thread_status; 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; 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 */ 158 void *postcopy_tmp_zero_page; 159 /* PostCopyFD's for external userfaultfds & handlers of shared memory */ 160 GArray *postcopy_remote_fds; 161 162 QEMUBH *bh; 163 164 int state; 165 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 173 /* The coroutine we should enter (back) after failover */ 174 Coroutine *colo_incoming_co; 175 QemuSemaphore colo_incoming_sem; 176 177 /* 178 * PostcopyBlocktimeContext to keep information for postcopy 179 * live migration, to calculate vCPU block time 180 * */ 181 struct PostcopyBlocktimeContext *blocktime_ctx; 182 183 /* notify PAUSED postcopy incoming migrations to try to continue */ 184 QemuSemaphore postcopy_pause_sem_dst; 185 QemuSemaphore postcopy_pause_sem_fault; 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; 193 194 /* List of listening socket addresses */ 195 SocketAddressList *socket_address_list; 196 197 /* A tree of pages that we requested to the source VM */ 198 GTree *page_requested; 199 /* 200 * For postcopy only, count the number of requested page faults that 201 * still haven't been resolved. 202 */ 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; 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; 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; 231 }; 232 233 MigrationIncomingState *migration_incoming_get_current(void); 234 void migration_incoming_state_destroy(void); 235 void migration_incoming_transport_cleanup(MigrationIncomingState *mis); 236 /* 237 * Functions to work with blocktime context 238 */ 239 void fill_destination_postcopy_migration_info(MigrationInfo *info); 240 241 #define TYPE_MIGRATION "migration" 242 243 typedef struct MigrationClass MigrationClass; 244 DECLARE_OBJ_CHECKERS(MigrationState, MigrationClass, 245 MIGRATION_OBJ, TYPE_MIGRATION) 246 247 struct MigrationClass { 248 /*< private >*/ 249 DeviceClass parent_class; 250 }; 251 252 struct MigrationState { 253 /*< private >*/ 254 DeviceState parent_obj; 255 256 /*< public >*/ 257 QemuThread thread; 258 QEMUBH *vm_start_bh; 259 QEMUBH *cleanup_bh; 260 /* Protected by qemu_file_lock */ 261 QEMUFile *to_dst_file; 262 /* Postcopy specific transfer channel */ 263 QEMUFile *postcopy_qemufile_src; 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; 271 QIOChannelBuffer *bioc; 272 /* 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. 276 */ 277 QemuMutex qemu_file_lock; 278 279 /* 280 * Used to allow urgent requests to override rate limiting. 281 */ 282 QemuSemaphore rate_limit_sem; 283 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 */ 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, or avail-switchover-bandwidth if specified. 298 */ 299 int64_t threshold_size; 300 301 /* params from 'migrate-set-parameters' */ 302 MigrationParameters parameters; 303 304 int state; 305 306 /* State related to return path */ 307 struct { 308 /* Protected by qemu_file_lock */ 309 QEMUFile *from_dst_file; 310 QemuThread rp_thread; 311 bool error; 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; 319 /* 320 * Used to synchronize between migration main thread and return 321 * path thread. The migration thread can wait() on this sem, while 322 * other threads (e.g., return path thread) can kick it using a 323 * post(). 324 */ 325 QemuSemaphore rp_sem; 326 /* 327 * We post to this when we got one PONG from dest. So far it's an 328 * easy way to know the main channel has successfully established 329 * on dest QEMU. 330 */ 331 QemuSemaphore rp_pong_acks; 332 } rp_state; 333 334 double mbps; 335 /* Timestamp when recent migration starts (ms) */ 336 int64_t start_time; 337 /* Total time used by latest migration (ms) */ 338 int64_t total_time; 339 /* Timestamp when VM is down (ms) to migrate the last stuff */ 340 int64_t downtime_start; 341 int64_t downtime; 342 int64_t expected_downtime; 343 bool capabilities[MIGRATION_CAPABILITY__MAX]; 344 int64_t setup_time; 345 346 /* 347 * State before stopping the vm by vm_stop_force_state(). 348 * If migration is interrupted by any reason, we need to continue 349 * running the guest on source if it was running or restore its stopped 350 * state. 351 */ 352 RunState vm_old_state; 353 354 /* Flag set once the migration has been asked to enter postcopy */ 355 bool start_postcopy; 356 /* Flag set after postcopy has sent the device state */ 357 bool postcopy_after_devices; 358 359 /* Flag set once the migration thread is running (and needs joining) */ 360 bool migration_thread_running; 361 362 /* Flag set once the migration thread called bdrv_inactivate_all */ 363 bool block_inactive; 364 365 /* Migration is waiting for guest to unplug device */ 366 QemuSemaphore wait_unplug_sem; 367 368 /* Migration is paused due to pause-before-switchover */ 369 QemuSemaphore pause_sem; 370 371 /* The semaphore is used to notify COLO thread that failover is finished */ 372 QemuSemaphore colo_exit_sem; 373 374 /* The event is used to notify COLO thread to do checkpoint */ 375 QemuEvent colo_checkpoint_event; 376 int64_t colo_checkpoint_time; 377 QEMUTimer *colo_delay_timer; 378 379 /* The first error that has occurred. 380 We used the mutex to be able to return the 1st error message */ 381 Error *error; 382 /* mutex to protect errp */ 383 QemuMutex error_mutex; 384 385 /* Do we have to clean up -b/-i from old migrate parameters */ 386 /* This feature is deprecated and will be removed */ 387 bool must_remove_block_options; 388 389 /* 390 * Global switch on whether we need to store the global state 391 * during migration. 392 */ 393 bool store_global_state; 394 395 /* Whether we send QEMU_VM_CONFIGURATION during migration */ 396 bool send_configuration; 397 /* Whether we send section footer during migration */ 398 bool send_section_footer; 399 400 /* Needed by postcopy-pause state */ 401 QemuSemaphore postcopy_pause_sem; 402 /* 403 * Whether we abort the migration if decompression errors are 404 * detected at the destination. It is left at false for qemu 405 * older than 3.0, since only newer qemu sends streams that 406 * do not trigger spurious decompression errors. 407 */ 408 bool decompress_error_check; 409 /* 410 * This variable only affects behavior when postcopy preempt mode is 411 * enabled. 412 * 413 * When set: 414 * 415 * - postcopy preempt src QEMU instance will generate an EOS message at 416 * the end of migration to shut the preempt channel on dest side. 417 * 418 * - postcopy preempt channel will be created at the setup phase on src 419 QEMU. 420 * 421 * When clear: 422 * 423 * - postcopy preempt src QEMU instance will _not_ generate an EOS 424 * message at the end of migration, the dest qemu will shutdown the 425 * channel itself. 426 * 427 * - postcopy preempt channel will be created at the switching phase 428 * from precopy -> postcopy (to avoid race condition of misordered 429 * creation of channels). 430 * 431 * NOTE: See message-id <ZBoShWArKDPpX/D7@work-vm> on qemu-devel 432 * mailing list for more information on the possible race. Everyone 433 * should probably just keep this value untouched after set by the 434 * machine type (or the default). 435 */ 436 bool preempt_pre_7_2; 437 438 /* 439 * flush every channel after each section sent. 440 * 441 * This assures that we can't mix pages from one iteration through 442 * ram pages with pages for the following iteration. We really 443 * only need to do this flush after we have go through all the 444 * dirty pages. For historical reasons, we do that after each 445 * section. This is suboptimal (we flush too many times). 446 * Default value is false. (since 8.1) 447 */ 448 bool multifd_flush_after_each_section; 449 /* 450 * This decides the size of guest memory chunk that will be used 451 * to track dirty bitmap clearing. The size of memory chunk will 452 * be GUEST_PAGE_SIZE << N. Say, N=0 means we will clear dirty 453 * bitmap for each page to send (1<<0=1); N=10 means we will clear 454 * dirty bitmap only once for 1<<10=1K continuous guest pages 455 * (which is in 4M chunk). 456 */ 457 uint8_t clear_bitmap_shift; 458 459 /* 460 * This save hostname when out-going migration starts 461 */ 462 char *hostname; 463 464 /* QEMU_VM_VMDESCRIPTION content filled for all non-iterable devices. */ 465 JSONWriter *vmdesc; 466 467 /* 468 * Indicates whether an ACK from the destination that it's OK to do 469 * switchover has been received. 470 */ 471 bool switchover_acked; 472 /* Is this a rdma migration */ 473 bool rdma_migration; 474 }; 475 476 void migrate_set_state(int *state, int old_state, int new_state); 477 478 void migration_fd_process_incoming(QEMUFile *f, Error **errp); 479 void migration_ioc_process_incoming(QIOChannel *ioc, Error **errp); 480 void migration_incoming_process(void); 481 482 bool migration_has_all_channels(void); 483 484 uint64_t migrate_max_downtime(void); 485 486 void migrate_set_error(MigrationState *s, const Error *error); 487 bool migrate_has_error(MigrationState *s); 488 489 void migrate_fd_connect(MigrationState *s, Error *error_in); 490 491 bool migration_is_setup_or_active(int state); 492 bool migration_is_running(int state); 493 494 int migrate_init(MigrationState *s, Error **errp); 495 bool migration_is_blocked(Error **errp); 496 /* True if outgoing migration has entered postcopy phase */ 497 bool migration_in_postcopy(void); 498 MigrationState *migrate_get_current(void); 499 500 uint64_t ram_get_total_transferred_pages(void); 501 502 /* Sending on the return path - generic and then for each message type */ 503 void migrate_send_rp_shut(MigrationIncomingState *mis, 504 uint32_t value); 505 void migrate_send_rp_pong(MigrationIncomingState *mis, 506 uint32_t value); 507 int migrate_send_rp_req_pages(MigrationIncomingState *mis, RAMBlock *rb, 508 ram_addr_t start, uint64_t haddr); 509 int migrate_send_rp_message_req_pages(MigrationIncomingState *mis, 510 RAMBlock *rb, ram_addr_t start); 511 void migrate_send_rp_recv_bitmap(MigrationIncomingState *mis, 512 char *block_name); 513 void migrate_send_rp_resume_ack(MigrationIncomingState *mis, uint32_t value); 514 int migrate_send_rp_switchover_ack(MigrationIncomingState *mis); 515 516 void dirty_bitmap_mig_before_vm_start(void); 517 void dirty_bitmap_mig_cancel_outgoing(void); 518 void dirty_bitmap_mig_cancel_incoming(void); 519 bool check_dirty_bitmap_mig_alias_map(const BitmapMigrationNodeAliasList *bbm, 520 Error **errp); 521 522 void migrate_add_address(SocketAddress *address); 523 524 int foreach_not_ignored_block(RAMBlockIterFunc func, void *opaque); 525 526 #define qemu_ram_foreach_block \ 527 #warning "Use foreach_not_ignored_block in migration code" 528 529 void migration_make_urgent_request(void); 530 void migration_consume_urgent_request(void); 531 bool migration_rate_limit(void); 532 void migration_cancel(const Error *error); 533 534 void migration_populate_vfio_info(MigrationInfo *info); 535 void migration_reset_vfio_bytes_transferred(void); 536 void postcopy_temp_page_reset(PostcopyTmpPage *tmp_page); 537 538 /* Migration thread waiting for return path thread. */ 539 void migration_rp_wait(MigrationState *s); 540 /* 541 * Kick the migration thread waiting for return path messages. NOTE: the 542 * name can be slightly confusing (when read as "kick the rp thread"), just 543 * to remember the target is always the migration thread. 544 */ 545 void migration_rp_kick(MigrationState *s); 546 547 #endif 548