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 /* State for the incoming migration */ 28 struct MigrationIncomingState { 29 QEMUFile *from_src_file; 30 31 /* 32 * Free at the start of the main state load, set as the main thread finishes 33 * loading state. 34 */ 35 QemuEvent main_thread_load_event; 36 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; 43 44 bool have_listen_thread; 45 QemuThread listen_thread; 46 QemuSemaphore listen_thread_sem; 47 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; 60 61 QEMUBH *bh; 62 63 int state; 64 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; 70 71 /* 72 * PostcopyBlocktimeContext to keep information for postcopy 73 * live migration, to calculate vCPU block time 74 * */ 75 struct PostcopyBlocktimeContext *blocktime_ctx; 76 }; 77 78 MigrationIncomingState *migration_incoming_get_current(void); 79 void migration_incoming_state_destroy(void); 80 /* 81 * Functions to work with blocktime context 82 */ 83 void fill_destination_postcopy_migration_info(MigrationInfo *info); 84 85 #define TYPE_MIGRATION "migration" 86 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) 93 94 typedef struct MigrationClass { 95 /*< private >*/ 96 DeviceClass parent_class; 97 } MigrationClass; 98 99 struct MigrationState 100 { 101 /*< private >*/ 102 DeviceState parent_obj; 103 104 /*< public >*/ 105 size_t bytes_xfer; 106 size_t xfer_limit; 107 QemuThread thread; 108 QEMUBH *cleanup_bh; 109 QEMUFile *to_dst_file; 110 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; 115 /* 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 119 */ 120 int64_t threshold_size; 121 122 /* params from 'migrate-set-parameters' */ 123 MigrationParameters parameters; 124 125 int state; 126 127 /* State related to return path */ 128 struct { 129 QEMUFile *from_dst_file; 130 QemuThread rp_thread; 131 bool error; 132 } rp_state; 133 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; 145 /* 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. 149 */ 150 bool vm_was_running; 151 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; 156 157 /* Flag set once the migration thread is running (and needs joining) */ 158 bool migration_thread_running; 159 160 /* Flag set once the migration thread called bdrv_inactivate_all */ 161 bool block_inactive; 162 163 /* Migration is paused due to pause-before-switchover */ 164 QemuSemaphore pause_sem; 165 166 /* The semaphore is used to notify COLO thread that failover is finished */ 167 QemuSemaphore colo_exit_sem; 168 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; 173 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; 179 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; 183 184 /* 185 * Global switch on whether we need to store the global state 186 * during migration. 187 */ 188 bool store_global_state; 189 190 /* Whether the VM is only allowing for migratable devices */ 191 bool only_migratable; 192 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; 197 }; 198 199 void migrate_set_state(int *state, int old_state, int new_state); 200 201 void migration_fd_process_incoming(QEMUFile *f); 202 void migration_ioc_process_incoming(QIOChannel *ioc); 203 204 bool migration_has_all_channels(void); 205 206 uint64_t migrate_max_downtime(void); 207 208 void migrate_set_error(MigrationState *s, const Error *error); 209 void migrate_fd_error(MigrationState *s, const Error *error); 210 211 void migrate_fd_connect(MigrationState *s, Error *error_in); 212 213 void migrate_init(MigrationState *s); 214 bool migration_is_blocked(Error **errp); 215 /* True if outgoing migration has entered postcopy phase */ 216 bool migration_in_postcopy(void); 217 MigrationState *migrate_get_current(void); 218 219 bool migrate_postcopy(void); 220 221 bool migrate_release_ram(void); 222 bool migrate_postcopy_ram(void); 223 bool migrate_zero_blocks(void); 224 bool migrate_dirty_bitmaps(void); 225 226 bool migrate_auto_converge(void); 227 bool migrate_use_multifd(void); 228 bool migrate_pause_before_switchover(void); 229 int migrate_multifd_channels(void); 230 int migrate_multifd_page_count(void); 231 232 int migrate_use_xbzrle(void); 233 int64_t migrate_xbzrle_cache_size(void); 234 bool migrate_colo_enabled(void); 235 236 bool migrate_use_block(void); 237 bool migrate_use_block_incremental(void); 238 bool migrate_use_return_path(void); 239 240 bool migrate_use_compression(void); 241 int migrate_compress_level(void); 242 int migrate_compress_threads(void); 243 int migrate_decompress_threads(void); 244 bool migrate_use_events(void); 245 bool migrate_postcopy_blocktime(void); 246 247 /* Sending on the return path - generic and then for each message type */ 248 void migrate_send_rp_shut(MigrationIncomingState *mis, 249 uint32_t value); 250 void migrate_send_rp_pong(MigrationIncomingState *mis, 251 uint32_t value); 252 int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char* rbname, 253 ram_addr_t start, size_t len); 254 255 void dirty_bitmap_mig_before_vm_start(void); 256 void init_dirty_bitmap_incoming_migration(void); 257 258 #endif 259