1 /* 2 * Migration support for VFIO devices 3 * 4 * Copyright NVIDIA, Inc. 2020 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2. See 7 * the COPYING file in the top-level directory. 8 */ 9 10 #include "qemu/osdep.h" 11 #include "qemu/main-loop.h" 12 #include "qemu/cutils.h" 13 #include "qemu/units.h" 14 #include "qemu/error-report.h" 15 #include <linux/vfio.h> 16 #include <sys/ioctl.h> 17 18 #include "sysemu/runstate.h" 19 #include "hw/vfio/vfio-common.h" 20 #include "migration/migration.h" 21 #include "migration/options.h" 22 #include "migration/savevm.h" 23 #include "migration/vmstate.h" 24 #include "migration/qemu-file.h" 25 #include "migration/register.h" 26 #include "migration/blocker.h" 27 #include "migration/misc.h" 28 #include "qapi/error.h" 29 #include "exec/ramlist.h" 30 #include "exec/ram_addr.h" 31 #include "pci.h" 32 #include "trace.h" 33 #include "hw/hw.h" 34 35 /* 36 * Flags to be used as unique delimiters for VFIO devices in the migration 37 * stream. These flags are composed as: 38 * 0xffffffff => MSB 32-bit all 1s 39 * 0xef10 => Magic ID, represents emulated (virtual) function IO 40 * 0x0000 => 16-bits reserved for flags 41 * 42 * The beginning of state information is marked by _DEV_CONFIG_STATE, 43 * _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a 44 * certain state information is marked by _END_OF_STATE. 45 */ 46 #define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) 47 #define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) 48 #define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) 49 #define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) 50 #define VFIO_MIG_FLAG_DEV_INIT_DATA_SENT (0xffffffffef100005ULL) 51 52 /* 53 * This is an arbitrary size based on migration of mlx5 devices, where typically 54 * total device migration size is on the order of 100s of MB. Testing with 55 * larger values, e.g. 128MB and 1GB, did not show a performance improvement. 56 */ 57 #define VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE (1 * MiB) 58 59 static int64_t bytes_transferred; 60 61 static const char *mig_state_to_str(enum vfio_device_mig_state state) 62 { 63 switch (state) { 64 case VFIO_DEVICE_STATE_ERROR: 65 return "ERROR"; 66 case VFIO_DEVICE_STATE_STOP: 67 return "STOP"; 68 case VFIO_DEVICE_STATE_RUNNING: 69 return "RUNNING"; 70 case VFIO_DEVICE_STATE_STOP_COPY: 71 return "STOP_COPY"; 72 case VFIO_DEVICE_STATE_RESUMING: 73 return "RESUMING"; 74 case VFIO_DEVICE_STATE_RUNNING_P2P: 75 return "RUNNING_P2P"; 76 case VFIO_DEVICE_STATE_PRE_COPY: 77 return "PRE_COPY"; 78 case VFIO_DEVICE_STATE_PRE_COPY_P2P: 79 return "PRE_COPY_P2P"; 80 default: 81 return "UNKNOWN STATE"; 82 } 83 } 84 85 static int vfio_migration_set_state(VFIODevice *vbasedev, 86 enum vfio_device_mig_state new_state, 87 enum vfio_device_mig_state recover_state) 88 { 89 VFIOMigration *migration = vbasedev->migration; 90 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 91 sizeof(struct vfio_device_feature_mig_state), 92 sizeof(uint64_t))] = {}; 93 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 94 struct vfio_device_feature_mig_state *mig_state = 95 (struct vfio_device_feature_mig_state *)feature->data; 96 int ret; 97 98 feature->argsz = sizeof(buf); 99 feature->flags = 100 VFIO_DEVICE_FEATURE_SET | VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE; 101 mig_state->device_state = new_state; 102 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 103 /* Try to set the device in some good state */ 104 ret = -errno; 105 106 if (recover_state == VFIO_DEVICE_STATE_ERROR) { 107 error_report("%s: Failed setting device state to %s, err: %s. " 108 "Recover state is ERROR. Resetting device", 109 vbasedev->name, mig_state_to_str(new_state), 110 strerror(errno)); 111 112 goto reset_device; 113 } 114 115 error_report( 116 "%s: Failed setting device state to %s, err: %s. Setting device in recover state %s", 117 vbasedev->name, mig_state_to_str(new_state), 118 strerror(errno), mig_state_to_str(recover_state)); 119 120 mig_state->device_state = recover_state; 121 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 122 ret = -errno; 123 error_report( 124 "%s: Failed setting device in recover state, err: %s. Resetting device", 125 vbasedev->name, strerror(errno)); 126 127 goto reset_device; 128 } 129 130 migration->device_state = recover_state; 131 132 return ret; 133 } 134 135 migration->device_state = new_state; 136 if (mig_state->data_fd != -1) { 137 if (migration->data_fd != -1) { 138 /* 139 * This can happen if the device is asynchronously reset and 140 * terminates a data transfer. 141 */ 142 error_report("%s: data_fd out of sync", vbasedev->name); 143 close(mig_state->data_fd); 144 145 return -EBADF; 146 } 147 148 migration->data_fd = mig_state->data_fd; 149 } 150 151 trace_vfio_migration_set_state(vbasedev->name, mig_state_to_str(new_state)); 152 153 return 0; 154 155 reset_device: 156 if (ioctl(vbasedev->fd, VFIO_DEVICE_RESET)) { 157 hw_error("%s: Failed resetting device, err: %s", vbasedev->name, 158 strerror(errno)); 159 } 160 161 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 162 163 return ret; 164 } 165 166 static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, 167 uint64_t data_size) 168 { 169 VFIOMigration *migration = vbasedev->migration; 170 int ret; 171 172 ret = qemu_file_get_to_fd(f, migration->data_fd, data_size); 173 trace_vfio_load_state_device_data(vbasedev->name, data_size, ret); 174 175 return ret; 176 } 177 178 static int vfio_save_device_config_state(QEMUFile *f, void *opaque) 179 { 180 VFIODevice *vbasedev = opaque; 181 182 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_CONFIG_STATE); 183 184 if (vbasedev->ops && vbasedev->ops->vfio_save_config) { 185 vbasedev->ops->vfio_save_config(vbasedev, f); 186 } 187 188 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 189 190 trace_vfio_save_device_config_state(vbasedev->name); 191 192 return qemu_file_get_error(f); 193 } 194 195 static int vfio_load_device_config_state(QEMUFile *f, void *opaque) 196 { 197 VFIODevice *vbasedev = opaque; 198 uint64_t data; 199 200 if (vbasedev->ops && vbasedev->ops->vfio_load_config) { 201 int ret; 202 203 ret = vbasedev->ops->vfio_load_config(vbasedev, f); 204 if (ret) { 205 error_report("%s: Failed to load device config space", 206 vbasedev->name); 207 return ret; 208 } 209 } 210 211 data = qemu_get_be64(f); 212 if (data != VFIO_MIG_FLAG_END_OF_STATE) { 213 error_report("%s: Failed loading device config space, " 214 "end flag incorrect 0x%"PRIx64, vbasedev->name, data); 215 return -EINVAL; 216 } 217 218 trace_vfio_load_device_config_state(vbasedev->name); 219 return qemu_file_get_error(f); 220 } 221 222 static void vfio_migration_cleanup(VFIODevice *vbasedev) 223 { 224 VFIOMigration *migration = vbasedev->migration; 225 226 close(migration->data_fd); 227 migration->data_fd = -1; 228 } 229 230 static int vfio_query_stop_copy_size(VFIODevice *vbasedev, 231 uint64_t *stop_copy_size) 232 { 233 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 234 sizeof(struct vfio_device_feature_mig_data_size), 235 sizeof(uint64_t))] = {}; 236 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 237 struct vfio_device_feature_mig_data_size *mig_data_size = 238 (struct vfio_device_feature_mig_data_size *)feature->data; 239 240 feature->argsz = sizeof(buf); 241 feature->flags = 242 VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIG_DATA_SIZE; 243 244 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 245 return -errno; 246 } 247 248 *stop_copy_size = mig_data_size->stop_copy_length; 249 250 return 0; 251 } 252 253 static int vfio_query_precopy_size(VFIOMigration *migration) 254 { 255 struct vfio_precopy_info precopy = { 256 .argsz = sizeof(precopy), 257 }; 258 259 migration->precopy_init_size = 0; 260 migration->precopy_dirty_size = 0; 261 262 if (ioctl(migration->data_fd, VFIO_MIG_GET_PRECOPY_INFO, &precopy)) { 263 return -errno; 264 } 265 266 migration->precopy_init_size = precopy.initial_bytes; 267 migration->precopy_dirty_size = precopy.dirty_bytes; 268 269 return 0; 270 } 271 272 /* Returns the size of saved data on success and -errno on error */ 273 static ssize_t vfio_save_block(QEMUFile *f, VFIOMigration *migration) 274 { 275 ssize_t data_size; 276 277 data_size = read(migration->data_fd, migration->data_buffer, 278 migration->data_buffer_size); 279 if (data_size < 0) { 280 /* 281 * Pre-copy emptied all the device state for now. For more information, 282 * please refer to the Linux kernel VFIO uAPI. 283 */ 284 if (errno == ENOMSG) { 285 return 0; 286 } 287 288 return -errno; 289 } 290 if (data_size == 0) { 291 return 0; 292 } 293 294 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_DATA_STATE); 295 qemu_put_be64(f, data_size); 296 qemu_put_buffer(f, migration->data_buffer, data_size); 297 bytes_transferred += data_size; 298 299 trace_vfio_save_block(migration->vbasedev->name, data_size); 300 301 return qemu_file_get_error(f) ?: data_size; 302 } 303 304 static void vfio_update_estimated_pending_data(VFIOMigration *migration, 305 uint64_t data_size) 306 { 307 if (!data_size) { 308 /* 309 * Pre-copy emptied all the device state for now, update estimated sizes 310 * accordingly. 311 */ 312 migration->precopy_init_size = 0; 313 migration->precopy_dirty_size = 0; 314 315 return; 316 } 317 318 if (migration->precopy_init_size) { 319 uint64_t init_size = MIN(migration->precopy_init_size, data_size); 320 321 migration->precopy_init_size -= init_size; 322 data_size -= init_size; 323 } 324 325 migration->precopy_dirty_size -= MIN(migration->precopy_dirty_size, 326 data_size); 327 } 328 329 static bool vfio_precopy_supported(VFIODevice *vbasedev) 330 { 331 VFIOMigration *migration = vbasedev->migration; 332 333 return migration->mig_flags & VFIO_MIGRATION_PRE_COPY; 334 } 335 336 /* ---------------------------------------------------------------------- */ 337 338 static int vfio_save_prepare(void *opaque, Error **errp) 339 { 340 VFIODevice *vbasedev = opaque; 341 342 /* 343 * Snapshot doesn't use postcopy nor background snapshot, so allow snapshot 344 * even if they are on. 345 */ 346 if (runstate_check(RUN_STATE_SAVE_VM)) { 347 return 0; 348 } 349 350 if (migrate_postcopy_ram()) { 351 error_setg( 352 errp, "%s: VFIO migration is not supported with postcopy migration", 353 vbasedev->name); 354 return -EOPNOTSUPP; 355 } 356 357 if (migrate_background_snapshot()) { 358 error_setg( 359 errp, 360 "%s: VFIO migration is not supported with background snapshot", 361 vbasedev->name); 362 return -EOPNOTSUPP; 363 } 364 365 return 0; 366 } 367 368 static int vfio_save_setup(QEMUFile *f, void *opaque) 369 { 370 VFIODevice *vbasedev = opaque; 371 VFIOMigration *migration = vbasedev->migration; 372 uint64_t stop_copy_size = VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE; 373 374 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_SETUP_STATE); 375 376 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 377 migration->data_buffer_size = MIN(VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE, 378 stop_copy_size); 379 migration->data_buffer = g_try_malloc0(migration->data_buffer_size); 380 if (!migration->data_buffer) { 381 error_report("%s: Failed to allocate migration data buffer", 382 vbasedev->name); 383 return -ENOMEM; 384 } 385 386 if (vfio_precopy_supported(vbasedev)) { 387 int ret; 388 389 switch (migration->device_state) { 390 case VFIO_DEVICE_STATE_RUNNING: 391 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_PRE_COPY, 392 VFIO_DEVICE_STATE_RUNNING); 393 if (ret) { 394 return ret; 395 } 396 397 vfio_query_precopy_size(migration); 398 399 break; 400 case VFIO_DEVICE_STATE_STOP: 401 /* vfio_save_complete_precopy() will go to STOP_COPY */ 402 break; 403 default: 404 return -EINVAL; 405 } 406 } 407 408 trace_vfio_save_setup(vbasedev->name, migration->data_buffer_size); 409 410 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 411 412 return qemu_file_get_error(f); 413 } 414 415 static void vfio_save_cleanup(void *opaque) 416 { 417 VFIODevice *vbasedev = opaque; 418 VFIOMigration *migration = vbasedev->migration; 419 420 /* 421 * Changing device state from STOP_COPY to STOP can take time. Do it here, 422 * after migration has completed, so it won't increase downtime. 423 */ 424 if (migration->device_state == VFIO_DEVICE_STATE_STOP_COPY) { 425 /* 426 * If setting the device in STOP state fails, the device should be 427 * reset. To do so, use ERROR state as a recover state. 428 */ 429 vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP, 430 VFIO_DEVICE_STATE_ERROR); 431 } 432 433 g_free(migration->data_buffer); 434 migration->data_buffer = NULL; 435 migration->precopy_init_size = 0; 436 migration->precopy_dirty_size = 0; 437 migration->initial_data_sent = false; 438 vfio_migration_cleanup(vbasedev); 439 trace_vfio_save_cleanup(vbasedev->name); 440 } 441 442 static void vfio_state_pending_estimate(void *opaque, uint64_t *must_precopy, 443 uint64_t *can_postcopy) 444 { 445 VFIODevice *vbasedev = opaque; 446 VFIOMigration *migration = vbasedev->migration; 447 448 if (!vfio_device_state_is_precopy(vbasedev)) { 449 return; 450 } 451 452 *must_precopy += 453 migration->precopy_init_size + migration->precopy_dirty_size; 454 455 trace_vfio_state_pending_estimate(vbasedev->name, *must_precopy, 456 *can_postcopy, 457 migration->precopy_init_size, 458 migration->precopy_dirty_size); 459 } 460 461 /* 462 * Migration size of VFIO devices can be as little as a few KBs or as big as 463 * many GBs. This value should be big enough to cover the worst case. 464 */ 465 #define VFIO_MIG_STOP_COPY_SIZE (100 * GiB) 466 467 static void vfio_state_pending_exact(void *opaque, uint64_t *must_precopy, 468 uint64_t *can_postcopy) 469 { 470 VFIODevice *vbasedev = opaque; 471 VFIOMigration *migration = vbasedev->migration; 472 uint64_t stop_copy_size = VFIO_MIG_STOP_COPY_SIZE; 473 474 /* 475 * If getting pending migration size fails, VFIO_MIG_STOP_COPY_SIZE is 476 * reported so downtime limit won't be violated. 477 */ 478 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 479 *must_precopy += stop_copy_size; 480 481 if (vfio_device_state_is_precopy(vbasedev)) { 482 vfio_query_precopy_size(migration); 483 484 *must_precopy += 485 migration->precopy_init_size + migration->precopy_dirty_size; 486 } 487 488 trace_vfio_state_pending_exact(vbasedev->name, *must_precopy, *can_postcopy, 489 stop_copy_size, migration->precopy_init_size, 490 migration->precopy_dirty_size); 491 } 492 493 static bool vfio_is_active_iterate(void *opaque) 494 { 495 VFIODevice *vbasedev = opaque; 496 497 return vfio_device_state_is_precopy(vbasedev); 498 } 499 500 static int vfio_save_iterate(QEMUFile *f, void *opaque) 501 { 502 VFIODevice *vbasedev = opaque; 503 VFIOMigration *migration = vbasedev->migration; 504 ssize_t data_size; 505 506 data_size = vfio_save_block(f, migration); 507 if (data_size < 0) { 508 return data_size; 509 } 510 511 vfio_update_estimated_pending_data(migration, data_size); 512 513 if (migrate_switchover_ack() && !migration->precopy_init_size && 514 !migration->initial_data_sent) { 515 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_INIT_DATA_SENT); 516 migration->initial_data_sent = true; 517 } else { 518 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 519 } 520 521 trace_vfio_save_iterate(vbasedev->name, migration->precopy_init_size, 522 migration->precopy_dirty_size); 523 524 /* 525 * A VFIO device's pre-copy dirty_bytes is not guaranteed to reach zero. 526 * Return 1 so following handlers will not be potentially blocked. 527 */ 528 return 1; 529 } 530 531 static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) 532 { 533 VFIODevice *vbasedev = opaque; 534 ssize_t data_size; 535 int ret; 536 537 /* We reach here with device state STOP or STOP_COPY only */ 538 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP_COPY, 539 VFIO_DEVICE_STATE_STOP); 540 if (ret) { 541 return ret; 542 } 543 544 do { 545 data_size = vfio_save_block(f, vbasedev->migration); 546 if (data_size < 0) { 547 return data_size; 548 } 549 } while (data_size); 550 551 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 552 ret = qemu_file_get_error(f); 553 if (ret) { 554 return ret; 555 } 556 557 trace_vfio_save_complete_precopy(vbasedev->name, ret); 558 559 return ret; 560 } 561 562 static void vfio_save_state(QEMUFile *f, void *opaque) 563 { 564 VFIODevice *vbasedev = opaque; 565 int ret; 566 567 ret = vfio_save_device_config_state(f, opaque); 568 if (ret) { 569 error_report("%s: Failed to save device config space", 570 vbasedev->name); 571 qemu_file_set_error(f, ret); 572 } 573 } 574 575 static int vfio_load_setup(QEMUFile *f, void *opaque) 576 { 577 VFIODevice *vbasedev = opaque; 578 579 return vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RESUMING, 580 vbasedev->migration->device_state); 581 } 582 583 static int vfio_load_cleanup(void *opaque) 584 { 585 VFIODevice *vbasedev = opaque; 586 587 vfio_migration_cleanup(vbasedev); 588 trace_vfio_load_cleanup(vbasedev->name); 589 590 return 0; 591 } 592 593 static int vfio_load_state(QEMUFile *f, void *opaque, int version_id) 594 { 595 VFIODevice *vbasedev = opaque; 596 int ret = 0; 597 uint64_t data; 598 599 data = qemu_get_be64(f); 600 while (data != VFIO_MIG_FLAG_END_OF_STATE) { 601 602 trace_vfio_load_state(vbasedev->name, data); 603 604 switch (data) { 605 case VFIO_MIG_FLAG_DEV_CONFIG_STATE: 606 { 607 return vfio_load_device_config_state(f, opaque); 608 } 609 case VFIO_MIG_FLAG_DEV_SETUP_STATE: 610 { 611 data = qemu_get_be64(f); 612 if (data == VFIO_MIG_FLAG_END_OF_STATE) { 613 return ret; 614 } else { 615 error_report("%s: SETUP STATE: EOS not found 0x%"PRIx64, 616 vbasedev->name, data); 617 return -EINVAL; 618 } 619 break; 620 } 621 case VFIO_MIG_FLAG_DEV_DATA_STATE: 622 { 623 uint64_t data_size = qemu_get_be64(f); 624 625 if (data_size) { 626 ret = vfio_load_buffer(f, vbasedev, data_size); 627 if (ret < 0) { 628 return ret; 629 } 630 } 631 break; 632 } 633 case VFIO_MIG_FLAG_DEV_INIT_DATA_SENT: 634 { 635 if (!vfio_precopy_supported(vbasedev) || 636 !migrate_switchover_ack()) { 637 error_report("%s: Received INIT_DATA_SENT but switchover ack " 638 "is not used", vbasedev->name); 639 return -EINVAL; 640 } 641 642 ret = qemu_loadvm_approve_switchover(); 643 if (ret) { 644 error_report( 645 "%s: qemu_loadvm_approve_switchover failed, err=%d (%s)", 646 vbasedev->name, ret, strerror(-ret)); 647 } 648 649 return ret; 650 } 651 default: 652 error_report("%s: Unknown tag 0x%"PRIx64, vbasedev->name, data); 653 return -EINVAL; 654 } 655 656 data = qemu_get_be64(f); 657 ret = qemu_file_get_error(f); 658 if (ret) { 659 return ret; 660 } 661 } 662 return ret; 663 } 664 665 static bool vfio_switchover_ack_needed(void *opaque) 666 { 667 VFIODevice *vbasedev = opaque; 668 669 return vfio_precopy_supported(vbasedev); 670 } 671 672 static const SaveVMHandlers savevm_vfio_handlers = { 673 .save_prepare = vfio_save_prepare, 674 .save_setup = vfio_save_setup, 675 .save_cleanup = vfio_save_cleanup, 676 .state_pending_estimate = vfio_state_pending_estimate, 677 .state_pending_exact = vfio_state_pending_exact, 678 .is_active_iterate = vfio_is_active_iterate, 679 .save_live_iterate = vfio_save_iterate, 680 .save_live_complete_precopy = vfio_save_complete_precopy, 681 .save_state = vfio_save_state, 682 .load_setup = vfio_load_setup, 683 .load_cleanup = vfio_load_cleanup, 684 .load_state = vfio_load_state, 685 .switchover_ack_needed = vfio_switchover_ack_needed, 686 }; 687 688 /* ---------------------------------------------------------------------- */ 689 690 static void vfio_vmstate_change_prepare(void *opaque, bool running, 691 RunState state) 692 { 693 VFIODevice *vbasedev = opaque; 694 VFIOMigration *migration = vbasedev->migration; 695 enum vfio_device_mig_state new_state; 696 int ret; 697 698 new_state = migration->device_state == VFIO_DEVICE_STATE_PRE_COPY ? 699 VFIO_DEVICE_STATE_PRE_COPY_P2P : 700 VFIO_DEVICE_STATE_RUNNING_P2P; 701 702 /* 703 * If setting the device in new_state fails, the device should be reset. 704 * To do so, use ERROR state as a recover state. 705 */ 706 ret = vfio_migration_set_state(vbasedev, new_state, 707 VFIO_DEVICE_STATE_ERROR); 708 if (ret) { 709 /* 710 * Migration should be aborted in this case, but vm_state_notify() 711 * currently does not support reporting failures. 712 */ 713 if (migrate_get_current()->to_dst_file) { 714 qemu_file_set_error(migrate_get_current()->to_dst_file, ret); 715 } 716 } 717 718 trace_vfio_vmstate_change_prepare(vbasedev->name, running, 719 RunState_str(state), 720 mig_state_to_str(new_state)); 721 } 722 723 static void vfio_vmstate_change(void *opaque, bool running, RunState state) 724 { 725 VFIODevice *vbasedev = opaque; 726 enum vfio_device_mig_state new_state; 727 int ret; 728 729 if (running) { 730 new_state = VFIO_DEVICE_STATE_RUNNING; 731 } else { 732 new_state = 733 (vfio_device_state_is_precopy(vbasedev) && 734 (state == RUN_STATE_FINISH_MIGRATE || state == RUN_STATE_PAUSED)) ? 735 VFIO_DEVICE_STATE_STOP_COPY : 736 VFIO_DEVICE_STATE_STOP; 737 } 738 739 /* 740 * If setting the device in new_state fails, the device should be reset. 741 * To do so, use ERROR state as a recover state. 742 */ 743 ret = vfio_migration_set_state(vbasedev, new_state, 744 VFIO_DEVICE_STATE_ERROR); 745 if (ret) { 746 /* 747 * Migration should be aborted in this case, but vm_state_notify() 748 * currently does not support reporting failures. 749 */ 750 if (migrate_get_current()->to_dst_file) { 751 qemu_file_set_error(migrate_get_current()->to_dst_file, ret); 752 } 753 } 754 755 trace_vfio_vmstate_change(vbasedev->name, running, RunState_str(state), 756 mig_state_to_str(new_state)); 757 } 758 759 static void vfio_migration_state_notifier(Notifier *notifier, void *data) 760 { 761 MigrationState *s = data; 762 VFIOMigration *migration = container_of(notifier, VFIOMigration, 763 migration_state); 764 VFIODevice *vbasedev = migration->vbasedev; 765 766 trace_vfio_migration_state_notifier(vbasedev->name, 767 MigrationStatus_str(s->state)); 768 769 switch (s->state) { 770 case MIGRATION_STATUS_CANCELLING: 771 case MIGRATION_STATUS_CANCELLED: 772 case MIGRATION_STATUS_FAILED: 773 /* 774 * If setting the device in RUNNING state fails, the device should 775 * be reset. To do so, use ERROR state as a recover state. 776 */ 777 vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RUNNING, 778 VFIO_DEVICE_STATE_ERROR); 779 } 780 } 781 782 static void vfio_migration_free(VFIODevice *vbasedev) 783 { 784 g_free(vbasedev->migration); 785 vbasedev->migration = NULL; 786 } 787 788 static int vfio_migration_query_flags(VFIODevice *vbasedev, uint64_t *mig_flags) 789 { 790 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 791 sizeof(struct vfio_device_feature_migration), 792 sizeof(uint64_t))] = {}; 793 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 794 struct vfio_device_feature_migration *mig = 795 (struct vfio_device_feature_migration *)feature->data; 796 797 feature->argsz = sizeof(buf); 798 feature->flags = VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIGRATION; 799 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 800 return -errno; 801 } 802 803 *mig_flags = mig->flags; 804 805 return 0; 806 } 807 808 static bool vfio_dma_logging_supported(VFIODevice *vbasedev) 809 { 810 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature), 811 sizeof(uint64_t))] = {}; 812 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 813 814 feature->argsz = sizeof(buf); 815 feature->flags = VFIO_DEVICE_FEATURE_PROBE | 816 VFIO_DEVICE_FEATURE_DMA_LOGGING_START; 817 818 return !ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature); 819 } 820 821 static int vfio_migration_init(VFIODevice *vbasedev) 822 { 823 int ret; 824 Object *obj; 825 VFIOMigration *migration; 826 char id[256] = ""; 827 g_autofree char *path = NULL, *oid = NULL; 828 uint64_t mig_flags = 0; 829 VMChangeStateHandler *prepare_cb; 830 831 if (!vbasedev->ops->vfio_get_object) { 832 return -EINVAL; 833 } 834 835 obj = vbasedev->ops->vfio_get_object(vbasedev); 836 if (!obj) { 837 return -EINVAL; 838 } 839 840 ret = vfio_migration_query_flags(vbasedev, &mig_flags); 841 if (ret) { 842 return ret; 843 } 844 845 /* Basic migration functionality must be supported */ 846 if (!(mig_flags & VFIO_MIGRATION_STOP_COPY)) { 847 return -EOPNOTSUPP; 848 } 849 850 vbasedev->migration = g_new0(VFIOMigration, 1); 851 migration = vbasedev->migration; 852 migration->vbasedev = vbasedev; 853 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 854 migration->data_fd = -1; 855 migration->mig_flags = mig_flags; 856 857 vbasedev->dirty_pages_supported = vfio_dma_logging_supported(vbasedev); 858 859 oid = vmstate_if_get_id(VMSTATE_IF(DEVICE(obj))); 860 if (oid) { 861 path = g_strdup_printf("%s/vfio", oid); 862 } else { 863 path = g_strdup("vfio"); 864 } 865 strpadcpy(id, sizeof(id), path, '\0'); 866 867 register_savevm_live(id, VMSTATE_INSTANCE_ID_ANY, 1, &savevm_vfio_handlers, 868 vbasedev); 869 870 prepare_cb = migration->mig_flags & VFIO_MIGRATION_P2P ? 871 vfio_vmstate_change_prepare : 872 NULL; 873 migration->vm_state = qdev_add_vm_change_state_handler_full( 874 vbasedev->dev, vfio_vmstate_change, prepare_cb, vbasedev); 875 migration->migration_state.notify = vfio_migration_state_notifier; 876 add_migration_state_change_notifier(&migration->migration_state); 877 878 return 0; 879 } 880 881 static void vfio_migration_deinit(VFIODevice *vbasedev) 882 { 883 VFIOMigration *migration = vbasedev->migration; 884 885 remove_migration_state_change_notifier(&migration->migration_state); 886 qemu_del_vm_change_state_handler(migration->vm_state); 887 unregister_savevm(VMSTATE_IF(vbasedev->dev), "vfio", vbasedev); 888 vfio_migration_free(vbasedev); 889 vfio_unblock_multiple_devices_migration(); 890 } 891 892 static int vfio_block_migration(VFIODevice *vbasedev, Error *err, Error **errp) 893 { 894 int ret; 895 896 if (vbasedev->enable_migration == ON_OFF_AUTO_ON) { 897 error_propagate(errp, err); 898 return -EINVAL; 899 } 900 901 vbasedev->migration_blocker = error_copy(err); 902 error_free(err); 903 904 ret = migrate_add_blocker(vbasedev->migration_blocker, errp); 905 if (ret < 0) { 906 error_free(vbasedev->migration_blocker); 907 vbasedev->migration_blocker = NULL; 908 } 909 910 return ret; 911 } 912 913 /* ---------------------------------------------------------------------- */ 914 915 int64_t vfio_mig_bytes_transferred(void) 916 { 917 return bytes_transferred; 918 } 919 920 void vfio_reset_bytes_transferred(void) 921 { 922 bytes_transferred = 0; 923 } 924 925 /* 926 * Return true when either migration initialized or blocker registered. 927 * Currently only return false when adding blocker fails which will 928 * de-register vfio device. 929 */ 930 bool vfio_migration_realize(VFIODevice *vbasedev, Error **errp) 931 { 932 Error *err = NULL; 933 int ret; 934 935 if (vbasedev->enable_migration == ON_OFF_AUTO_OFF) { 936 error_setg(&err, "%s: Migration is disabled for VFIO device", 937 vbasedev->name); 938 return !vfio_block_migration(vbasedev, err, errp); 939 } 940 941 ret = vfio_migration_init(vbasedev); 942 if (ret) { 943 if (ret == -ENOTTY) { 944 error_setg(&err, "%s: VFIO migration is not supported in kernel", 945 vbasedev->name); 946 } else { 947 error_setg(&err, 948 "%s: Migration couldn't be initialized for VFIO device, " 949 "err: %d (%s)", 950 vbasedev->name, ret, strerror(-ret)); 951 } 952 953 return !vfio_block_migration(vbasedev, err, errp); 954 } 955 956 if (!vbasedev->dirty_pages_supported) { 957 if (vbasedev->enable_migration == ON_OFF_AUTO_AUTO) { 958 error_setg(&err, 959 "%s: VFIO device doesn't support device dirty tracking", 960 vbasedev->name); 961 goto add_blocker; 962 } 963 964 warn_report("%s: VFIO device doesn't support device dirty tracking", 965 vbasedev->name); 966 } 967 968 ret = vfio_block_multiple_devices_migration(vbasedev, errp); 969 if (ret) { 970 goto out_deinit; 971 } 972 973 if (vfio_viommu_preset(vbasedev)) { 974 error_setg(&err, "%s: Migration is currently not supported " 975 "with vIOMMU enabled", vbasedev->name); 976 goto add_blocker; 977 } 978 979 trace_vfio_migration_realize(vbasedev->name); 980 return true; 981 982 add_blocker: 983 ret = vfio_block_migration(vbasedev, err, errp); 984 out_deinit: 985 if (ret) { 986 vfio_migration_deinit(vbasedev); 987 } 988 return !ret; 989 } 990 991 void vfio_migration_exit(VFIODevice *vbasedev) 992 { 993 if (vbasedev->migration) { 994 vfio_migration_deinit(vbasedev); 995 } 996 997 if (vbasedev->migration_blocker) { 998 migrate_del_blocker(vbasedev->migration_blocker); 999 error_free(vbasedev->migration_blocker); 1000 vbasedev->migration_blocker = NULL; 1001 } 1002 } 1003