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 <linux/vfio.h> 15 #include <sys/ioctl.h> 16 17 #include "sysemu/runstate.h" 18 #include "hw/vfio/vfio-common.h" 19 #include "migration/migration.h" 20 #include "migration/vmstate.h" 21 #include "migration/qemu-file.h" 22 #include "migration/register.h" 23 #include "migration/blocker.h" 24 #include "migration/misc.h" 25 #include "qapi/error.h" 26 #include "exec/ramlist.h" 27 #include "exec/ram_addr.h" 28 #include "pci.h" 29 #include "trace.h" 30 #include "hw/hw.h" 31 32 /* 33 * Flags to be used as unique delimiters for VFIO devices in the migration 34 * stream. These flags are composed as: 35 * 0xffffffff => MSB 32-bit all 1s 36 * 0xef10 => Magic ID, represents emulated (virtual) function IO 37 * 0x0000 => 16-bits reserved for flags 38 * 39 * The beginning of state information is marked by _DEV_CONFIG_STATE, 40 * _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a 41 * certain state information is marked by _END_OF_STATE. 42 */ 43 #define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) 44 #define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) 45 #define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) 46 #define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) 47 48 /* 49 * This is an arbitrary size based on migration of mlx5 devices, where typically 50 * total device migration size is on the order of 100s of MB. Testing with 51 * larger values, e.g. 128MB and 1GB, did not show a performance improvement. 52 */ 53 #define VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE (1 * MiB) 54 55 static int64_t bytes_transferred; 56 57 static const char *mig_state_to_str(enum vfio_device_mig_state state) 58 { 59 switch (state) { 60 case VFIO_DEVICE_STATE_ERROR: 61 return "ERROR"; 62 case VFIO_DEVICE_STATE_STOP: 63 return "STOP"; 64 case VFIO_DEVICE_STATE_RUNNING: 65 return "RUNNING"; 66 case VFIO_DEVICE_STATE_STOP_COPY: 67 return "STOP_COPY"; 68 case VFIO_DEVICE_STATE_RESUMING: 69 return "RESUMING"; 70 default: 71 return "UNKNOWN STATE"; 72 } 73 } 74 75 static int vfio_migration_set_state(VFIODevice *vbasedev, 76 enum vfio_device_mig_state new_state, 77 enum vfio_device_mig_state recover_state) 78 { 79 VFIOMigration *migration = vbasedev->migration; 80 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 81 sizeof(struct vfio_device_feature_mig_state), 82 sizeof(uint64_t))] = {}; 83 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 84 struct vfio_device_feature_mig_state *mig_state = 85 (struct vfio_device_feature_mig_state *)feature->data; 86 int ret; 87 88 feature->argsz = sizeof(buf); 89 feature->flags = 90 VFIO_DEVICE_FEATURE_SET | VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE; 91 mig_state->device_state = new_state; 92 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 93 /* Try to set the device in some good state */ 94 ret = -errno; 95 96 if (recover_state == VFIO_DEVICE_STATE_ERROR) { 97 error_report("%s: Failed setting device state to %s, err: %s. " 98 "Recover state is ERROR. Resetting device", 99 vbasedev->name, mig_state_to_str(new_state), 100 strerror(errno)); 101 102 goto reset_device; 103 } 104 105 error_report( 106 "%s: Failed setting device state to %s, err: %s. Setting device in recover state %s", 107 vbasedev->name, mig_state_to_str(new_state), 108 strerror(errno), mig_state_to_str(recover_state)); 109 110 mig_state->device_state = recover_state; 111 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 112 ret = -errno; 113 error_report( 114 "%s: Failed setting device in recover state, err: %s. Resetting device", 115 vbasedev->name, strerror(errno)); 116 117 goto reset_device; 118 } 119 120 migration->device_state = recover_state; 121 122 return ret; 123 } 124 125 migration->device_state = new_state; 126 if (mig_state->data_fd != -1) { 127 if (migration->data_fd != -1) { 128 /* 129 * This can happen if the device is asynchronously reset and 130 * terminates a data transfer. 131 */ 132 error_report("%s: data_fd out of sync", vbasedev->name); 133 close(mig_state->data_fd); 134 135 return -EBADF; 136 } 137 138 migration->data_fd = mig_state->data_fd; 139 } 140 141 trace_vfio_migration_set_state(vbasedev->name, mig_state_to_str(new_state)); 142 143 return 0; 144 145 reset_device: 146 if (ioctl(vbasedev->fd, VFIO_DEVICE_RESET)) { 147 hw_error("%s: Failed resetting device, err: %s", vbasedev->name, 148 strerror(errno)); 149 } 150 151 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 152 153 return ret; 154 } 155 156 static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, 157 uint64_t data_size) 158 { 159 VFIOMigration *migration = vbasedev->migration; 160 int ret; 161 162 ret = qemu_file_get_to_fd(f, migration->data_fd, data_size); 163 trace_vfio_load_state_device_data(vbasedev->name, data_size, ret); 164 165 return ret; 166 } 167 168 static int vfio_save_device_config_state(QEMUFile *f, void *opaque) 169 { 170 VFIODevice *vbasedev = opaque; 171 172 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_CONFIG_STATE); 173 174 if (vbasedev->ops && vbasedev->ops->vfio_save_config) { 175 vbasedev->ops->vfio_save_config(vbasedev, f); 176 } 177 178 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 179 180 trace_vfio_save_device_config_state(vbasedev->name); 181 182 return qemu_file_get_error(f); 183 } 184 185 static int vfio_load_device_config_state(QEMUFile *f, void *opaque) 186 { 187 VFIODevice *vbasedev = opaque; 188 uint64_t data; 189 190 if (vbasedev->ops && vbasedev->ops->vfio_load_config) { 191 int ret; 192 193 ret = vbasedev->ops->vfio_load_config(vbasedev, f); 194 if (ret) { 195 error_report("%s: Failed to load device config space", 196 vbasedev->name); 197 return ret; 198 } 199 } 200 201 data = qemu_get_be64(f); 202 if (data != VFIO_MIG_FLAG_END_OF_STATE) { 203 error_report("%s: Failed loading device config space, " 204 "end flag incorrect 0x%"PRIx64, vbasedev->name, data); 205 return -EINVAL; 206 } 207 208 trace_vfio_load_device_config_state(vbasedev->name); 209 return qemu_file_get_error(f); 210 } 211 212 static void vfio_migration_cleanup(VFIODevice *vbasedev) 213 { 214 VFIOMigration *migration = vbasedev->migration; 215 216 close(migration->data_fd); 217 migration->data_fd = -1; 218 } 219 220 static int vfio_query_stop_copy_size(VFIODevice *vbasedev, 221 uint64_t *stop_copy_size) 222 { 223 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 224 sizeof(struct vfio_device_feature_mig_data_size), 225 sizeof(uint64_t))] = {}; 226 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 227 struct vfio_device_feature_mig_data_size *mig_data_size = 228 (struct vfio_device_feature_mig_data_size *)feature->data; 229 230 feature->argsz = sizeof(buf); 231 feature->flags = 232 VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIG_DATA_SIZE; 233 234 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 235 return -errno; 236 } 237 238 *stop_copy_size = mig_data_size->stop_copy_length; 239 240 return 0; 241 } 242 243 /* Returns 1 if end-of-stream is reached, 0 if more data and -errno if error */ 244 static int vfio_save_block(QEMUFile *f, VFIOMigration *migration) 245 { 246 ssize_t data_size; 247 248 data_size = read(migration->data_fd, migration->data_buffer, 249 migration->data_buffer_size); 250 if (data_size < 0) { 251 return -errno; 252 } 253 if (data_size == 0) { 254 return 1; 255 } 256 257 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_DATA_STATE); 258 qemu_put_be64(f, data_size); 259 qemu_put_buffer(f, migration->data_buffer, data_size); 260 bytes_transferred += data_size; 261 262 trace_vfio_save_block(migration->vbasedev->name, data_size); 263 264 return qemu_file_get_error(f); 265 } 266 267 /* ---------------------------------------------------------------------- */ 268 269 static int vfio_save_setup(QEMUFile *f, void *opaque) 270 { 271 VFIODevice *vbasedev = opaque; 272 VFIOMigration *migration = vbasedev->migration; 273 uint64_t stop_copy_size = VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE; 274 275 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_SETUP_STATE); 276 277 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 278 migration->data_buffer_size = MIN(VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE, 279 stop_copy_size); 280 migration->data_buffer = g_try_malloc0(migration->data_buffer_size); 281 if (!migration->data_buffer) { 282 error_report("%s: Failed to allocate migration data buffer", 283 vbasedev->name); 284 return -ENOMEM; 285 } 286 287 trace_vfio_save_setup(vbasedev->name, migration->data_buffer_size); 288 289 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 290 291 return qemu_file_get_error(f); 292 } 293 294 static void vfio_save_cleanup(void *opaque) 295 { 296 VFIODevice *vbasedev = opaque; 297 VFIOMigration *migration = vbasedev->migration; 298 299 g_free(migration->data_buffer); 300 migration->data_buffer = NULL; 301 vfio_migration_cleanup(vbasedev); 302 trace_vfio_save_cleanup(vbasedev->name); 303 } 304 305 /* 306 * Migration size of VFIO devices can be as little as a few KBs or as big as 307 * many GBs. This value should be big enough to cover the worst case. 308 */ 309 #define VFIO_MIG_STOP_COPY_SIZE (100 * GiB) 310 311 /* 312 * Only exact function is implemented and not estimate function. The reason is 313 * that during pre-copy phase of migration the estimate function is called 314 * repeatedly while pending RAM size is over the threshold, thus migration 315 * can't converge and querying the VFIO device pending data size is useless. 316 */ 317 static void vfio_state_pending_exact(void *opaque, uint64_t *must_precopy, 318 uint64_t *can_postcopy) 319 { 320 VFIODevice *vbasedev = opaque; 321 uint64_t stop_copy_size = VFIO_MIG_STOP_COPY_SIZE; 322 323 /* 324 * If getting pending migration size fails, VFIO_MIG_STOP_COPY_SIZE is 325 * reported so downtime limit won't be violated. 326 */ 327 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 328 *must_precopy += stop_copy_size; 329 330 trace_vfio_state_pending_exact(vbasedev->name, *must_precopy, *can_postcopy, 331 stop_copy_size); 332 } 333 334 static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) 335 { 336 VFIODevice *vbasedev = opaque; 337 int ret; 338 339 /* We reach here with device state STOP only */ 340 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP_COPY, 341 VFIO_DEVICE_STATE_STOP); 342 if (ret) { 343 return ret; 344 } 345 346 do { 347 ret = vfio_save_block(f, vbasedev->migration); 348 if (ret < 0) { 349 return ret; 350 } 351 } while (!ret); 352 353 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 354 ret = qemu_file_get_error(f); 355 if (ret) { 356 return ret; 357 } 358 359 /* 360 * If setting the device in STOP state fails, the device should be reset. 361 * To do so, use ERROR state as a recover state. 362 */ 363 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP, 364 VFIO_DEVICE_STATE_ERROR); 365 trace_vfio_save_complete_precopy(vbasedev->name, ret); 366 367 return ret; 368 } 369 370 static void vfio_save_state(QEMUFile *f, void *opaque) 371 { 372 VFIODevice *vbasedev = opaque; 373 int ret; 374 375 ret = vfio_save_device_config_state(f, opaque); 376 if (ret) { 377 error_report("%s: Failed to save device config space", 378 vbasedev->name); 379 qemu_file_set_error(f, ret); 380 } 381 } 382 383 static int vfio_load_setup(QEMUFile *f, void *opaque) 384 { 385 VFIODevice *vbasedev = opaque; 386 387 return vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RESUMING, 388 vbasedev->migration->device_state); 389 } 390 391 static int vfio_load_cleanup(void *opaque) 392 { 393 VFIODevice *vbasedev = opaque; 394 395 vfio_migration_cleanup(vbasedev); 396 trace_vfio_load_cleanup(vbasedev->name); 397 398 return 0; 399 } 400 401 static int vfio_load_state(QEMUFile *f, void *opaque, int version_id) 402 { 403 VFIODevice *vbasedev = opaque; 404 int ret = 0; 405 uint64_t data; 406 407 data = qemu_get_be64(f); 408 while (data != VFIO_MIG_FLAG_END_OF_STATE) { 409 410 trace_vfio_load_state(vbasedev->name, data); 411 412 switch (data) { 413 case VFIO_MIG_FLAG_DEV_CONFIG_STATE: 414 { 415 return vfio_load_device_config_state(f, opaque); 416 } 417 case VFIO_MIG_FLAG_DEV_SETUP_STATE: 418 { 419 data = qemu_get_be64(f); 420 if (data == VFIO_MIG_FLAG_END_OF_STATE) { 421 return ret; 422 } else { 423 error_report("%s: SETUP STATE: EOS not found 0x%"PRIx64, 424 vbasedev->name, data); 425 return -EINVAL; 426 } 427 break; 428 } 429 case VFIO_MIG_FLAG_DEV_DATA_STATE: 430 { 431 uint64_t data_size = qemu_get_be64(f); 432 433 if (data_size) { 434 ret = vfio_load_buffer(f, vbasedev, data_size); 435 if (ret < 0) { 436 return ret; 437 } 438 } 439 break; 440 } 441 default: 442 error_report("%s: Unknown tag 0x%"PRIx64, vbasedev->name, data); 443 return -EINVAL; 444 } 445 446 data = qemu_get_be64(f); 447 ret = qemu_file_get_error(f); 448 if (ret) { 449 return ret; 450 } 451 } 452 return ret; 453 } 454 455 static const SaveVMHandlers savevm_vfio_handlers = { 456 .save_setup = vfio_save_setup, 457 .save_cleanup = vfio_save_cleanup, 458 .state_pending_exact = vfio_state_pending_exact, 459 .save_live_complete_precopy = vfio_save_complete_precopy, 460 .save_state = vfio_save_state, 461 .load_setup = vfio_load_setup, 462 .load_cleanup = vfio_load_cleanup, 463 .load_state = vfio_load_state, 464 }; 465 466 /* ---------------------------------------------------------------------- */ 467 468 static void vfio_vmstate_change(void *opaque, bool running, RunState state) 469 { 470 VFIODevice *vbasedev = opaque; 471 enum vfio_device_mig_state new_state; 472 int ret; 473 474 if (running) { 475 new_state = VFIO_DEVICE_STATE_RUNNING; 476 } else { 477 new_state = VFIO_DEVICE_STATE_STOP; 478 } 479 480 /* 481 * If setting the device in new_state fails, the device should be reset. 482 * To do so, use ERROR state as a recover state. 483 */ 484 ret = vfio_migration_set_state(vbasedev, new_state, 485 VFIO_DEVICE_STATE_ERROR); 486 if (ret) { 487 /* 488 * Migration should be aborted in this case, but vm_state_notify() 489 * currently does not support reporting failures. 490 */ 491 if (migrate_get_current()->to_dst_file) { 492 qemu_file_set_error(migrate_get_current()->to_dst_file, ret); 493 } 494 } 495 496 trace_vfio_vmstate_change(vbasedev->name, running, RunState_str(state), 497 mig_state_to_str(new_state)); 498 } 499 500 static void vfio_migration_state_notifier(Notifier *notifier, void *data) 501 { 502 MigrationState *s = data; 503 VFIOMigration *migration = container_of(notifier, VFIOMigration, 504 migration_state); 505 VFIODevice *vbasedev = migration->vbasedev; 506 507 trace_vfio_migration_state_notifier(vbasedev->name, 508 MigrationStatus_str(s->state)); 509 510 switch (s->state) { 511 case MIGRATION_STATUS_CANCELLING: 512 case MIGRATION_STATUS_CANCELLED: 513 case MIGRATION_STATUS_FAILED: 514 bytes_transferred = 0; 515 /* 516 * If setting the device in RUNNING state fails, the device should 517 * be reset. To do so, use ERROR state as a recover state. 518 */ 519 vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RUNNING, 520 VFIO_DEVICE_STATE_ERROR); 521 } 522 } 523 524 static void vfio_migration_free(VFIODevice *vbasedev) 525 { 526 g_free(vbasedev->migration); 527 vbasedev->migration = NULL; 528 } 529 530 static int vfio_migration_query_flags(VFIODevice *vbasedev, uint64_t *mig_flags) 531 { 532 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 533 sizeof(struct vfio_device_feature_migration), 534 sizeof(uint64_t))] = {}; 535 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 536 struct vfio_device_feature_migration *mig = 537 (struct vfio_device_feature_migration *)feature->data; 538 539 feature->argsz = sizeof(buf); 540 feature->flags = VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIGRATION; 541 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 542 if (errno == ENOTTY) { 543 error_report("%s: VFIO migration is not supported in kernel", 544 vbasedev->name); 545 } else { 546 error_report("%s: Failed to query VFIO migration support, err: %s", 547 vbasedev->name, strerror(errno)); 548 } 549 550 return -errno; 551 } 552 553 *mig_flags = mig->flags; 554 555 return 0; 556 } 557 558 static bool vfio_dma_logging_supported(VFIODevice *vbasedev) 559 { 560 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature), 561 sizeof(uint64_t))] = {}; 562 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 563 564 feature->argsz = sizeof(buf); 565 feature->flags = VFIO_DEVICE_FEATURE_PROBE | 566 VFIO_DEVICE_FEATURE_DMA_LOGGING_START; 567 568 return !ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature); 569 } 570 571 static int vfio_migration_init(VFIODevice *vbasedev) 572 { 573 int ret; 574 Object *obj; 575 VFIOMigration *migration; 576 char id[256] = ""; 577 g_autofree char *path = NULL, *oid = NULL; 578 uint64_t mig_flags = 0; 579 580 if (!vbasedev->ops->vfio_get_object) { 581 return -EINVAL; 582 } 583 584 obj = vbasedev->ops->vfio_get_object(vbasedev); 585 if (!obj) { 586 return -EINVAL; 587 } 588 589 ret = vfio_migration_query_flags(vbasedev, &mig_flags); 590 if (ret) { 591 return ret; 592 } 593 594 /* Basic migration functionality must be supported */ 595 if (!(mig_flags & VFIO_MIGRATION_STOP_COPY)) { 596 return -EOPNOTSUPP; 597 } 598 599 vbasedev->migration = g_new0(VFIOMigration, 1); 600 migration = vbasedev->migration; 601 migration->vbasedev = vbasedev; 602 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 603 migration->data_fd = -1; 604 605 vbasedev->dirty_pages_supported = vfio_dma_logging_supported(vbasedev); 606 607 oid = vmstate_if_get_id(VMSTATE_IF(DEVICE(obj))); 608 if (oid) { 609 path = g_strdup_printf("%s/vfio", oid); 610 } else { 611 path = g_strdup("vfio"); 612 } 613 strpadcpy(id, sizeof(id), path, '\0'); 614 615 register_savevm_live(id, VMSTATE_INSTANCE_ID_ANY, 1, &savevm_vfio_handlers, 616 vbasedev); 617 618 migration->vm_state = qdev_add_vm_change_state_handler(vbasedev->dev, 619 vfio_vmstate_change, 620 vbasedev); 621 migration->migration_state.notify = vfio_migration_state_notifier; 622 add_migration_state_change_notifier(&migration->migration_state); 623 624 return 0; 625 } 626 627 /* ---------------------------------------------------------------------- */ 628 629 int64_t vfio_mig_bytes_transferred(void) 630 { 631 return bytes_transferred; 632 } 633 634 int vfio_migration_realize(VFIODevice *vbasedev, Error **errp) 635 { 636 int ret = -ENOTSUP; 637 638 if (!vbasedev->enable_migration) { 639 goto add_blocker; 640 } 641 642 ret = vfio_migration_init(vbasedev); 643 if (ret) { 644 goto add_blocker; 645 } 646 647 ret = vfio_block_multiple_devices_migration(errp); 648 if (ret) { 649 return ret; 650 } 651 652 ret = vfio_block_giommu_migration(errp); 653 if (ret) { 654 return ret; 655 } 656 657 trace_vfio_migration_probe(vbasedev->name); 658 return 0; 659 660 add_blocker: 661 error_setg(&vbasedev->migration_blocker, 662 "VFIO device doesn't support migration"); 663 664 ret = migrate_add_blocker(vbasedev->migration_blocker, errp); 665 if (ret < 0) { 666 error_free(vbasedev->migration_blocker); 667 vbasedev->migration_blocker = NULL; 668 } 669 return ret; 670 } 671 672 void vfio_migration_exit(VFIODevice *vbasedev) 673 { 674 if (vbasedev->migration) { 675 VFIOMigration *migration = vbasedev->migration; 676 677 remove_migration_state_change_notifier(&migration->migration_state); 678 qemu_del_vm_change_state_handler(migration->vm_state); 679 unregister_savevm(VMSTATE_IF(vbasedev->dev), "vfio", vbasedev); 680 vfio_migration_free(vbasedev); 681 vfio_unblock_multiple_devices_migration(); 682 } 683 684 if (vbasedev->migration_blocker) { 685 migrate_del_blocker(vbasedev->migration_blocker); 686 error_free(vbasedev->migration_blocker); 687 vbasedev->migration_blocker = NULL; 688 } 689 } 690