Add migration support for VFIO devices
v27 cover Add migration support for VFIO devices
Hi,
This Patch set adds migration support for VFIO devices in QEMU.
This Patch set include patches as below:
Patch 1-2:
- Few code refactor
Patch 3:
- Added save and restore functions for PCI configuration space. Used pci_device_save() and pci_device_load() so that config space cache is saved and restored.
Patch 4-9:
- Generic migration functionality for VFIO device.
* This patch set adds functionality for PCI devices, but can be extended to other VFIO devices.
* Added all the basic functions required for pre-copy, stop-and-copy and resume phases of migration.
* Added state change notifier and from that notifier function, VFIO device's state changed is conveyed to VFIO device driver.
* During save setup phase and resume/load setup phase, migration region is queried and is used to read/write VFIO device data.
* .save_live_pending and .save_live_iterate are implemented to use QEMU's functionality of iteration during pre-copy phase.
* In .save_live_complete_precopy, that is in stop-and-copy phase, iteration to read data from VFIO device driver is implemented till pending bytes returned by driver are zero.
Patch 10
- Set DIRTY_MEMORY_MIGRATION flag in dirty log mask for migration with vIOMMU enabled.
Patch 11:
- Get migration capability from kernel module.
Patch 12-13:
- Add function to start and stop dirty pages tracking.
- Add vfio_listerner_log_sync to mark dirty pages. Dirty pages bitmap is queried per container. All pages pinned by vendor driver through vfio_pin_pages external API has to be marked as dirty during migration.
When there are CPU writes, CPU dirty page tracking can identify dirtied pages, but any page pinned by vendor driver can also be written by device. As of now there is no device which has hardware support for dirty page tracking. So all pages which are pinned by vendor driver should be considered as dirty.
In Qemu, marking pages dirty is only done when device is in stop-and-copy phase because if pages are marked dirty during pre-copy phase and content is transfered from source to distination, there is no way to know newly dirtied pages from the point they were copied earlier until device stops. To avoid repeated copy of same content, pinned pages are marked dirty only during stop-and-copy phase.
Patch 14:
When vIOMMU is enabled, used IOMMU notifier to get call back for mapped pages on replay during stop-and-copy phase.
Patch 15:
- With vIOMMU, IO virtual address range can get unmapped while in pre-copy phase of migration. In that case, unmap ioctl should return pages pinned in that range and QEMU should report corresponding guest physical pages dirty.
Patch 16:
- Make VFIO PCI device migration capable. If migration region is not provided by driver, migration is blocked.
Patch 17:
- Added VFIO device stats to MigrationInfo
Yet TODO:
Since there is no device which has hardware support for system memmory dirty bitmap tracking, right now there is no other API from vendor driver to VFIO IOMMU module to report dirty pages. In future, when such hardware support will be implemented, an API will be required in kernel such that vendor driver could report dirty pages to VFIO module during migration phases.
Below is the flow of state change for live migration where states in brackets represent VM state, migration state and VFIO device state as:
(VM state, MIGRATION_STATUS, VFIO_DEVICE_STATE)
Live migration save path:
QEMU normal running state
(RUNNING, _NONE, _RUNNING)
|
migrate_init spawns migration_thread.
(RUNNING, _SETUP, _RUNNING|_SAVING)
Migration thread then calls each device's .save_setup()
|
(RUNNING, _ACTIVE, _RUNNING|_SAVING)
If device is active, get pending bytes by .save_live_pending() if pending bytes >= threshold_size, call save_live_iterate() Data of VFIO device for pre-copy phase is copied.
Iterate till total pending bytes converge and are less than threshold
|
On migration completion, vCPUs stops and calls .save_live_complete_precopy for each active device. VFIO device is then transitioned in
_SAVING state.
(FINISH_MIGRATE, _DEVICE, _SAVING)
For VFIO device, iterate in .save_live_complete_precopy until pending data is 0.
(FINISH_MIGRATE, _DEVICE, _STOPPED)
|
(FINISH_MIGRATE, _COMPLETED, _STOPPED)
Migraton thread schedule cleanup bottom half and exit
Live migration resume path:
Incomming migration calls .load_setup for each device (RESTORE_VM, _ACTIVE, _STOPPED)
|
For each device, .load_state is called for that device section data (RESTORE_VM, _ACTIVE, _RESUMING)
|
At the end, called .load_cleanup for each device and vCPUs are started.
|
(RUNNING, _NONE, _RUNNING)
Note that:
- Migration post copy is not supported.
v26 -> 27
- Major change in Patch 3 -PCI config space save and long using VMSTATE_*
- Major change in Patch 14 - Dirty page tracking when vIOMMU is enabled using IOMMU notifier and its replay functionality - as suggested by Alex.
- Some Structure changes to keep all migration related members at one place.
- Pulled fix suggested by Zhi Wang <[email protected]>
https://www.mail-archive.com/[email protected]/msg743722.html
- Add comments where even suggested and required.
v25 -> 26
- Removed emulated_config_bits cache and vdev->pdev.wmask from config space save load functions.
- Used VMStateDescription for config space save and load functionality.
- Major fixes from previous version review.
https://www.mail-archive.com/[email protected]/msg714625.html
v23 -> 25
- Updated config space save and load to save config cache, emulated bits cache and wmask cache.
- Created idr string as suggested by Dr Dave that includes bus path.
- Updated save and load function to read/write data to mixed regions, mapped or trapped.
- When vIOMMU is enabled, created mapped iova range list which also keeps translated address. This list is used to mark dirty pages. This reduces downtime significantly with vIOMMU enabled than migration patches from previous version.
- Removed get_address_limit() function from v23 patch as this not required now.
v22 -> v23
-- Fixed issue reported by Yan
https://lore.kernel.org/kvm/[email protected]/
- Sending this version to test v23 kernel version patches:
https://lore.kernel.org/kvm/[email protected]/
v18 -> v22
- Few fixes from v18 review. But not yet fixed all concerns. I'll address those concerns in subsequent iterations.
- Sending this version to test v22 kernel version patches:
https://lore.kernel.org/kvm/[email protected]/
v16 -> v18
- Nit fixes
- Get migration capability flags from container
- Added VFIO stats to MigrationInfo
- Fixed bug reported by Yan
https://lists.gnu.org/archive/html/qemu-devel/2020-04/msg00004.html
v9 -> v16
- KABI almost finalised on kernel patches.
- Added support for migration with vIOMMU enabled.
v8 -> v9:
- Split patch set in 2 sets, Kernel and QEMU sets.
- Dirty pages bitmap is queried from IOMMU container rather than from vendor driver for per device. Added 2 ioctls to achieve this.
v7 -> v8:
- Updated comments for KABI
- Added BAR address validation check during PCI device's config space load as suggested by Dr. David Alan Gilbert.
- Changed vfio_migration_set_state() to set or clear device state flags.
- Some nit fixes.
v6 -> v7:
- Fix build failures.
v5 -> v6:
- Fix build failure.
v4 -> v5:
- Added decriptive comment about the sequence of access of members of structure vfio_device_migration_info to be followed based on Alex's suggestion
- Updated get dirty pages sequence.
- As per Cornelia Huck's suggestion, added callbacks to VFIODeviceOps to get_object, save_config and load_config.
- Fixed multiple nit picks.
- Tested live migration with multiple vfio device assigned to a VM.
v3 -> v4:
- Added one more bit for _RESUMING flag to be set explicitly.
- data_offset field is read-only for user space application.
- data_size is read for every iteration before reading data from migration, that is removed assumption that data will be till end of migration region.
- If vendor driver supports mappable sparsed region, map those region during setup state of save/load, similarly unmap those from cleanup routines.
- Handles race condition that causes data corruption in migration region during save device state by adding mutex and serialiaing save_buffer and get_dirty_pages routines.
- Skip called get_dirty_pages routine for mapped MMIO region of device.
- Added trace events.
- Splitted into multiple functional patches.
v2 -> v3:
- Removed enum of VFIO device states. Defined VFIO device state with 2 bits.
- Re-structured vfio_device_migration_info to keep it minimal and defined action on read and write access on its members.
v1 -> v2:
- Defined MIGRATION region type and sub-type which should be used with region type capability.
- Re-structured vfio_device_migration_info. This structure will be placed at 0th offset of migration region.
- Replaced ioctl with read/write for trapped part of migration region.
- Added both type of access support, trapped or mmapped, for data section of the region.
- Moved PCI device functions to pci file.
- Added iteration to get dirty page bitmap until bitmap for all requested pages are copied.
Thanks,
Kirti
Kirti Wankhede (17):
vfio: Add function to unmap VFIO region
vfio: Add vfio_get_object callback to VFIODeviceOps
vfio: Add save and load functions for VFIO PCI devices
vfio: Add migration region initialization and finalize function
vfio: Add VM state change handler to know state of VM
vfio: Add migration state change notifier
vfio: Register SaveVMHandlers for VFIO device
vfio: Add save state functions to SaveVMHandlers
vfio: Add load state functions to SaveVMHandlers
memory: Set DIRTY_MEMORY_MIGRATION when IOMMU is enabled
vfio: Get migration capability flags for container
vfio: Add function to start and stop dirty pages tracking
vfio: Add vfio_listener_log_sync to mark dirty pages
vfio: Dirty page tracking when vIOMMU is enabled
vfio: Add ioctl to get dirty pages bitmap during dma unmap
vfio: Make vfio-pci device migration capable
qapi: Add VFIO devices migration stats in Migration stats
hw/vfio/common.c | 449 +++++++++++++++++++- hw/vfio/meson.build | 1 + hw/vfio/migration.c | 935 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/pci.c | 84 +++- hw/vfio/pci.h | 1 - hw/vfio/trace-events | 20 + include/hw/vfio/vfio-common.h | 24 ++ include/qemu/vfio-helpers.h | 3 + migration/migration.c | 14 + monitor/hmp-cmds.c | 6 + qapi/migration.json | 17 + softmmu/memory.c | 2 +- 12 files changed, 1512 insertions(+), 44 deletions(-) create mode 100644 hw/vfio/migration.c
Signature · 1 line
2.7.0
PATCH v27 1/17 vfio: Add function to unmap VFIO region
This function will be used for migration region.
Migration region is mmaped when migration starts and will be unmapped when migration is complete.
--- hw/vfio/common.c | 32 ++++++++++++++++++++++++++++---- hw/vfio/trace-events | 1 + include/hw/vfio/vfio-common.h | 1 + 3 files changed, 30 insertions(+), 4 deletions(-)
hw/vfio/common.c +28 -4
@@ -924,6 +924,18 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region,return 0 ; } +static void vfio_subregion_unmap (VFIORegion *region,int index) +{ +trace_vfio_region_unmap (memory_region_name (®ion->mmaps[index].mem), + region->mmaps[index].offset, + region->mmaps[index].offset + + region->mmaps[index].size -1 ); +memory_region_del_subregion (region->mem, ®ion->mmaps[index].mem); +munmap (region->mmaps[index].mmap, region->mmaps[index].size); +object_unparent (OBJECT (®ion->mmaps[index].mem)); + region->mmaps[index].mmap =NULL ; +} +int vfio_region_mmap (VFIORegion *region) {int i, prot =0 ;
@@ -954,10 +966,7 @@ int vfio_region_mmap(VFIORegion *region) region->mmaps[i].mmap =NULL ;for (i--; i >=0 ; i--) { -memory_region_del_subregion (region->mem, ®ion->mmaps[i].mem); -munmap (region->mmaps[i].mmap, region->mmaps[i].size); -object_unparent (OBJECT (®ion->mmaps[i].mem)); - region->mmaps[i].mmap =NULL ; +vfio_subregion_unmap (region, i); }return ret;
@@ -982,6 +991,21 @@ int vfio_region_mmap(VFIORegion *region)return 0 ; } +void vfio_region_unmap (VFIORegion *region) +{ +int i; + +if (!region->mem) { +return ; + } + +for (i =0 ; i < region->nr_mmaps; i++) { +if (region->mmaps[i].mmap) { +vfio_subregion_unmap (region, i); + } + } +} +void vfio_region_exit (VFIORegion *region) {int i;
hw/vfio/trace-events +1 -0
@@ -113,6 +113,7 @@ vfio_region_mmap(const char *name, unsigned long offset, unsigned long end) "Reg vfio_region_exit(const char *name, int index) "Device %s, region %d" vfio_region_finalize(const char *name, int index) "Device %s, region %d" vfio_region_mmaps_set_enabled(const char *name, bool enabled) "Region %s mmaps enabled: %d" +vfio_region_unmap(const char *name, unsigned long offset, unsigned long end) "Region %s unmap [0x%lx - 0x%lx]" vfio_region_sparse_mmap_header(const char *name, int index, int nr_areas) "Device %s region %d: %d sparse mmap entries" vfio_region_sparse_mmap_entry(int i, unsigned long start, unsigned long end) "sparse entry %d [0x%lx - 0x%lx]" vfio_get_dev_region(const char *name, int index, uint32_t type, uint32_t subtype) "%s index %d, %08x/%0x8"
include/hw/vfio/vfio-common.h +1 -0
@@ -171,6 +171,7 @@ int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region, int index, const char *name);int vfio_region_mmap (VFIORegion *region);void vfio_region_mmaps_set_enabled (VFIORegion *region,bool enabled); +void vfio_region_unmap (VFIORegion *region);void vfio_region_exit (VFIORegion *region);void vfio_region_finalize (VFIORegion *region);void vfio_reset_handler (void *opaque);
Signature · 1 line
2.7.0
PATCH v27 2/17 vfio: Add vfio_get_object callback to VFIODeviceOps
In reply to Kirti WankhedeHook vfio_get_object callback for PCI devices.
--- hw/vfio/pci.c | 8 ++++++++ include/hw/vfio/vfio-common.h | 1 + 2 files changed, 9 insertions(+)
hw/vfio/pci.c +8 -0
@@ -2394,10 +2394,18 @@ static void vfio_pci_compute_needs_reset(VFIODevice *vbasedev) } } +static Object *vfio_pci_get_object (VFIODevice *vbasedev) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); + +return OBJECT (vdev); +} +static VFIODeviceOps vfio_pci_ops = { .vfio_compute_needs_reset = vfio_pci_compute_needs_reset, .vfio_hot_reset_multi = vfio_pci_hot_reset_multi, .vfio_eoi = vfio_intx_eoi, + .vfio_get_object = vfio_pci_get_object, };int vfio_populate_vga (VFIOPCIDevice *vdev,Error **errp)
include/hw/vfio/vfio-common.h +1 -0
@@ -119,6 +119,7 @@ struct VFIODeviceOps {void (*vfio_compute_needs_reset)(VFIODevice *vdev);int (*vfio_hot_reset_multi)(VFIODevice *vdev);void (*vfio_eoi)(VFIODevice *vdev); + Object *(*vfio_get_object)(VFIODevice *vdev); }; typedef struct VFIOGroup {
Signature · 1 line
2.7.0
PATCH v27 3/17 vfio: Add save and load functions for VFIO PCI devices
In reply to Kirti WankhedeAdded functions to save and restore PCI device specific data, specifically config space of PCI device.
--- hw/vfio/pci.c | 48 +++++++++++++++++++++++++++++++++++++++++++ include/hw/vfio/vfio-common.h | 2 ++ 2 files changed, 50 insertions(+)
hw/vfio/pci.c +48 -0
@@ -41,6 +41,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/blocker.h" +#include "migration/qemu-file.h" #define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"
@@ -2401,11 +2402,58 @@ static Object *vfio_pci_get_object(VFIODevice *vbasedev)return OBJECT (vdev); } +static bool vfio_msix_enabled (void *opaque,int version_id) +{ +PCIDevice *pdev = opaque; + +return msix_enabled (pdev); +} + +const VMStateDescription vmstate_vfio_pci_config = { + .name ="VFIOPCIDevice" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_PCI_DEVICE (pdev, VFIOPCIDevice), +VMSTATE_MSIX_TEST (pdev, VFIOPCIDevice, vfio_msix_enabled), +VMSTATE_END_OF_LIST () + } +}; + +static void vfio_pci_save_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); + +vmstate_save_state (f, &vmstate_vfio_pci_config, vdev,NULL ); +} + +static int vfio_pci_load_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); +PCIDevice *pdev = &vdev->pdev; +int ret; + + ret =vmstate_load_state (f, &vmstate_vfio_pci_config, vdev,1 ); +if (ret) { +return ret; + } + +if (msi_enabled (pdev)) { +vfio_msi_enable (vdev); + }else if (msix_enabled (pdev)) { +vfio_msix_enable (vdev); + } + +return ret; +} +static VFIODeviceOps vfio_pci_ops = { .vfio_compute_needs_reset = vfio_pci_compute_needs_reset, .vfio_hot_reset_multi = vfio_pci_hot_reset_multi, .vfio_eoi = vfio_intx_eoi, .vfio_get_object = vfio_pci_get_object, + .vfio_save_config = vfio_pci_save_config, + .vfio_load_config = vfio_pci_load_config, };int vfio_populate_vga (VFIOPCIDevice *vdev,Error **errp)
include/hw/vfio/vfio-common.h +2 -0
@@ -120,6 +120,8 @@ struct VFIODeviceOps {int (*vfio_hot_reset_multi)(VFIODevice *vdev);void (*vfio_eoi)(VFIODevice *vdev); Object *(*vfio_get_object)(VFIODevice *vdev); +void (*vfio_save_config)(VFIODevice *vdev,QEMUFile *f); +int (*vfio_load_config)(VFIODevice *vdev,QEMUFile *f); }; typedef struct VFIOGroup {
Signature · 1 line
2.7.0
Re: [PATCH v27 03/17] vfio: Add save and load functions for VFIO PCI devices
Quoted 23 lines · On Thu, 22 Oct 2020 16:41:53 +0530 Kirti Wankhede <[email protected]> wrote:
Added functions to save and restore PCI device specific data, specifically config space of PCI device.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/pci.c | 48 +++++++++++++++++++++++++++++++++++++++++++ include/hw/vfio/vfio-common.h | 2 ++ 2 files changed, 50 insertions(+)hw/vfio/pci.c +1
-0@@ -41,6 +41,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/blocker.h" +#include "migration/qemu-file.h" #define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"
hw/vfio/pci.c static Object *vfio_pci_get_object(VFIODevice *vbasedev) · line 2409
Quoted 8 lines
hw/vfio/pci.c +5
-0@@ -2401,11 +2402,58 @@ static Object *vfio_pci_get_object(VFIODevice *vbasedev)return OBJECT (vdev); } +static bool vfio_msix_enabled (void *opaque,int version_id) +{ +PCIDevice *pdev = opaque; + +return msix_enabled (pdev);
Why msix_enabled() rather than msix_present()? It seems that even if MSI-X is not enabled at the point in time where this is called, there's still emulated state in the vector table. For example if the guest has written the vectors but has not yet enabled the capability at the point where we start a migration, this test might cause the guest on the target to enable MSI-X with uninitialized data in the vector table.
hw/vfio/pci.c static Object *vfio_pci_get_object(VFIODevice *vbasedev) · line 2418
Quoted 9 lines
hw/vfio/pci.c +9
-0+} + +const VMStateDescription vmstate_vfio_pci_config = { + .name ="VFIOPCIDevice" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_PCI_DEVICE (pdev, VFIOPCIDevice), +VMSTATE_MSIX_TEST (pdev, VFIOPCIDevice, vfio_msix_enabled),
MSI (not-X) state is entirely in config space, so doesn't need a separate field, correct?
Otherwise this looks quite a bit cleaner than previous version, I hope VMState experts can confirm this is sufficiently extensible within the migration framework. Thanks,
Alex
Quoted 54 lines
hw/vfio/pci.c +33
-0+ VMSTATE_END_OF_LIST() + } +}; + +static void vfio_pci_save_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); + +vmstate_save_state (f, &vmstate_vfio_pci_config, vdev,NULL ); +} + +static int vfio_pci_load_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); +PCIDevice *pdev = &vdev->pdev; +int ret; + + ret =vmstate_load_state (f, &vmstate_vfio_pci_config, vdev,1 ); +if (ret) { +return ret; + } + +if (msi_enabled (pdev)) { +vfio_msi_enable (vdev); + }else if (msix_enabled (pdev)) { +vfio_msix_enable (vdev); + } + +return ret; +} +static VFIODeviceOps vfio_pci_ops = { .vfio_compute_needs_reset = vfio_pci_compute_needs_reset, .vfio_hot_reset_multi = vfio_pci_hot_reset_multi, .vfio_eoi = vfio_intx_eoi, .vfio_get_object = vfio_pci_get_object, + .vfio_save_config = vfio_pci_save_config, + .vfio_load_config = vfio_pci_load_config, };int vfio_populate_vga (VFIOPCIDevice *vdev,Error **errp)include/hw/vfio/vfio-common.h +2
-0@@ -120,6 +120,8 @@ struct VFIODeviceOps {int (*vfio_hot_reset_multi)(VFIODevice *vdev);void (*vfio_eoi)(VFIODevice *vdev); Object *(*vfio_get_object)(VFIODevice *vdev); +void (*vfio_save_config)(VFIODevice *vdev,QEMUFile *f); +int (*vfio_load_config)(VFIODevice *vdev,QEMUFile *f); }; typedef struct VFIOGroup {
Re: [PATCH v27 03/17] vfio: Add save and load functions for VFIO PCI devices
Quoted 29 lines · Alex Williamson
Quoted 26 lines · On Thu, 22 Oct 2020 16:41:53 +0530 Kirti Wankhede <[email protected]> wrote:
Added functions to save and restore PCI device specific data, specifically config space of PCI device.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/pci.c | 48 +++++++++++++++++++++++++++++++++++++++++++ include/hw/vfio/vfio-common.h | 2 ++ 2 files changed, 50 insertions(+)hw/vfio/pci.c +1
-0@@ -41,6 +41,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/blocker.h" +#include "migration/qemu-file.h" #define TYPE_VFIO_PCI_NOHOTPLUG "vfio-pci-nohotplug"@@ -2401,11 +2402,58 @@ static Object *vfio_pci_get_object(VFIODevice *vbasedev)return OBJECT (vdev); }
Quoted 13 lines
hw/vfio/pci.c static Object *vfio_pci_get_object(VFIODevice *vbasedev) · line 2409
Quoted 5 lines
hw/vfio/pci.c +5
-0+static bool vfio_msix_enabled (void *opaque,int version_id) +{ +PCIDevice *pdev = opaque; + +return msix_enabled (pdev);Why
msix_enabled()rather thanmsix_present()? It seems that even if MSI-X is not enabled at the point in time where this is called, there's still emulated state in the vector table. For example if the guest has written the vectors but has not yet enabled the capability at the point where we start a migration, this test might cause the guest on the target to enable MSI-X with uninitialized data in the vector table.
You're correct. Changing it to check if present.
Quoted 4 lines
Quoted 4 lines
hw/vfio/pci.c +4
-0+} + +const VMStateDescription vmstate_vfio_pci_config = { + .name ="VFIOPCIDevice" ,
Quoted 9 lines
hw/vfio/pci.c static Object *vfio_pci_get_object(VFIODevice *vbasedev) · line 2418
Quoted 5 lines
hw/vfio/pci.c +5
-0+ .version_id = 1, + .minimum_version_id = 1, + .fields = (VMStateField []) { +VMSTATE_PCI_DEVICE (pdev, VFIOPCIDevice), +VMSTATE_MSIX_TEST (pdev, VFIOPCIDevice, vfio_msix_enabled),MSI (not-X) state is entirely in config space, so doesn't need a separate field, correct?
Yes.
Quoted 4 lines
Otherwise this looks quite a bit cleaner than previous version, I hope VMState experts can confirm this is sufficiently extensible within the migration framework. Thanks,
Thanks,
Kirti
Quoted 57 lines
Alex
Quoted 54 lines
hw/vfio/pci.c +33
-0+ VMSTATE_END_OF_LIST() + } +}; + +static void vfio_pci_save_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); + +vmstate_save_state (f, &vmstate_vfio_pci_config, vdev,NULL ); +} + +static int vfio_pci_load_config (VFIODevice *vbasedev,QEMUFile *f) +{ +VFIOPCIDevice *vdev =container_of (vbasedev, VFIOPCIDevice, vbasedev); +PCIDevice *pdev = &vdev->pdev; +int ret; + + ret =vmstate_load_state (f, &vmstate_vfio_pci_config, vdev,1 ); +if (ret) { +return ret; + } + +if (msi_enabled (pdev)) { +vfio_msi_enable (vdev); + }else if (msix_enabled (pdev)) { +vfio_msix_enable (vdev); + } + +return ret; +} +static VFIODeviceOps vfio_pci_ops = { .vfio_compute_needs_reset = vfio_pci_compute_needs_reset, .vfio_hot_reset_multi = vfio_pci_hot_reset_multi, .vfio_eoi = vfio_intx_eoi, .vfio_get_object = vfio_pci_get_object, + .vfio_save_config = vfio_pci_save_config, + .vfio_load_config = vfio_pci_load_config, };int vfio_populate_vga (VFIOPCIDevice *vdev,Error **errp)include/hw/vfio/vfio-common.h +2
-0@@ -120,6 +120,8 @@ struct VFIODeviceOps {int (*vfio_hot_reset_multi)(VFIODevice *vdev);void (*vfio_eoi)(VFIODevice *vdev); Object *(*vfio_get_object)(VFIODevice *vdev); +void (*vfio_save_config)(VFIODevice *vdev,QEMUFile *f); +int (*vfio_load_config)(VFIODevice *vdev,QEMUFile *f); }; typedef struct VFIOGroup {
PATCH v27 4/17 vfio: Add migration region initialization and finalize function
In reply to Kirti WankhedeWhether the VFIO device supports migration or not is decided based of migration region query. If migration region query is successful and migration region initialization is successful then migration is supported else migration is blocked.
--- hw/vfio/meson.build | 1 + hw/vfio/migration.c | 129 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + include/hw/vfio/vfio-common.h | 9 +++ 4 files changed, 142 insertions(+) create mode 100644 hw/vfio/migration.c
hw/vfio/meson.build +1 -0
@@ -2,6 +2,7 @@ vfio_ss = ss.source_set() vfio_ss.add(files( 'common.c', 'spapr.c', + 'migration.c', )) vfio_ss.add(when: 'CONFIG_VFIO_PCI', if_true: files( 'display.c',
hw/vfio/migration.c new file +129 -0
129 lines not on this page · raw message
hw/vfio/trace-events +3 -0
@@ -145,3 +145,6 @@ vfio_display_edid_link_up(void) "" vfio_display_edid_link_down(void) "" vfio_display_edid_update(uint32_t prefx, uint32_t prefy) "%ux%u" vfio_display_edid_write_error(void) "" + +# migration.c +vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d"
include/hw/vfio/vfio-common.h +9 -0
@@ -57,6 +57,10 @@ typedef struct VFIORegion {uint8_t nr;/* cache the region number for debug */ } VFIORegion; +typedef struct VFIOMigration { +VFIORegion region; +}VFIOMigration ; + typedef struct VFIOAddressSpace { AddressSpace *as; QLIST_HEAD(, VFIOContainer) containers;
@@ -113,6 +117,8 @@ typedef struct VFIODevice {unsigned int num_irqs;unsigned int num_regions;unsigned int flags; +VFIOMigration *migration; +Error *migration_blocker; } VFIODevice;struct VFIODeviceOps {
@@ -204,4 +210,7 @@ int vfio_spapr_create_window(VFIOContainer *container,int vfio_spapr_remove_window (VFIOContainer *container,hwaddr offset_within_address_space); +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp); +void vfio_migration_finalize (VFIODevice *vbasedev); +#endif /* HW_VFIO_VFIO_COMMON_H */
Signature · 1 line
2.7.0
Re: [PATCH v27 04/17] vfio: Add migration region initialization and finalize function
Quoted 101 lines · On Thu, 22 Oct 2020 16:41:54 +0530 Kirti Wankhede <[email protected]> wrote:
Whether the VFIO device supports migration or not is decided based of migration region query. If migration region query is successful and migration region initialization is successful then migration is supported else migration is blocked.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/meson.build | 1 + hw/vfio/migration.c | 129 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + include/hw/vfio/vfio-common.h | 9 +++ 4 files changed, 142 insertions(+) create mode 100644 hw/vfio/migration.chw/vfio/meson.build +1
-0@@ -2,6 +2,7 @@ vfio_ss = ss.source_set() vfio_ss.add(files( 'common.c', 'spapr.c', + 'migration.c', )) vfio_ss.add(when: 'CONFIG_VFIO_PCI', if_true: files( 'display.c',hw/vfio/migration.c new file +67
-0@@ -0,0 +1,129 @@ +/* +* Migration support for VFIO devices +* +* Copyright NVIDIA, Inc. 2020 +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +*/ + +#include "qemu/osdep.h" +#include <linux/vfio.h> + +#include "hw/vfio/vfio-common.h" +#include "cpu.h" +#include "migration/migration.h" +#include "migration/qemu-file.h" +#include "migration/register.h" +#include "migration/blocker.h" +#include "migration/misc.h" +#include "qapi/error.h" +#include "exec/ramlist.h" +#include "exec/ram_addr.h" +#include "pci.h" +#include "trace.h" + +static void vfio_migration_region_exit (VFIODevice *vbasedev) +{ +VFIOMigration *migration = vbasedev->migration; + +if (!migration) { +return ; + } + +if (migration->region.size) { +vfio_region_exit (&migration->region); +vfio_region_finalize (&migration->region); + } +} + +static int vfio_migration_init (VFIODevice *vbasedev, +struct vfio_region_info *info) +{ +int ret; +Object *obj; +VFIOMigration *migration; + +if (!vbasedev->ops->vfio_get_object) { +return -EINVAL ; + } + + obj = vbasedev->ops->vfio_get_object (vbasedev); +if (!obj) { +return -EINVAL ; + } + + migration =g_new0 (VFIOMigration,1 ); + + ret =vfio_region_setup (obj, vbasedev, &migration->region, + info->index,"migration" ); +if (ret) { +error_report ("%s: Failed to setup VFIO migration region %d: %s" , + vbasedev->name, info->index,strerror (-ret)); + goto err; + } + +if (!migration->region.size) { + error_report("%s: Invalid zero-sized of VFIO migration region %d",
hw/vfio/migration.c line 77
Quoted 10 lines
hw/vfio/migration.c new file +10
-0+ vbasedev->name, info->index); + ret = -EINVAL ; + goto err; + } + + vbasedev->migration = migration; +return 0 ; + +err: +vfio_migration_region_exit (vbasedev);
We can't get here with vbasedev->migration set, did you intend to set vbasedev->migration before testing region.size? Thanks,
Alex
Quoted 95 lines
hw/vfio/migration.c new file +52
-0+g_free (migration); +return ret; +} + +/* ---------------------------------------------------------------------- */ + +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) +{ +struct vfio_region_info *info =NULL ; +Error *local_err =NULL ; +int ret; + + ret =vfio_get_dev_region_info (vbasedev,VFIO_REGION_TYPE_MIGRATION , +VFIO_REGION_SUBTYPE_MIGRATION , &info); +if (ret) { + goto add_blocker; + } + + ret =vfio_migration_init (vbasedev, info); +if (ret) { + goto add_blocker; + } + +g_free (info); +trace_vfio_migration_probe (vbasedev->name, info->index); +return 0 ; + +add_blocker: +error_setg (&vbasedev->migration_blocker, +"VFIO device doesn't support migration" ); +g_free (info); + + ret =migrate_add_blocker (vbasedev->migration_blocker, &local_err); +if (local_err) { +error_propagate (errp, local_err); +error_free (vbasedev->migration_blocker); + vbasedev->migration_blocker =NULL ; + } +return ret; +} + +void vfio_migration_finalize (VFIODevice *vbasedev) +{ +if (vbasedev->migration_blocker) { +migrate_del_blocker (vbasedev->migration_blocker); +error_free (vbasedev->migration_blocker); + vbasedev->migration_blocker =NULL ; + } + +vfio_migration_region_exit (vbasedev); +g_free (vbasedev->migration); +}hw/vfio/trace-events +3
-0@@ -145,3 +145,6 @@ vfio_display_edid_link_up(void) "" vfio_display_edid_link_down(void) "" vfio_display_edid_update(uint32_t prefx, uint32_t prefy) "%ux%u" vfio_display_edid_write_error(void) "" + +# migration.c +vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d"include/hw/vfio/vfio-common.h +9
-0@@ -57,6 +57,10 @@ typedef struct VFIORegion {uint8_t nr;/* cache the region number for debug */ } VFIORegion; +typedef struct VFIOMigration { +VFIORegion region; +}VFIOMigration ; + typedef struct VFIOAddressSpace { AddressSpace *as; QLIST_HEAD(, VFIOContainer) containers;@@ -113,6 +117,8 @@ typedef struct VFIODevice {unsigned int num_irqs;unsigned int num_regions;unsigned int flags; +VFIOMigration *migration; +Error *migration_blocker; } VFIODevice;struct VFIODeviceOps {@@ -204,4 +210,7 @@ int vfio_spapr_create_window(VFIOContainer *container,int vfio_spapr_remove_window (VFIOContainer *container,hwaddr offset_within_address_space); +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp); +void vfio_migration_finalize (VFIODevice *vbasedev); +#endif /* HW_VFIO_VFIO_COMMON_H */
Re: [PATCH v27 04/17] vfio: Add migration region initialization and finalize function
Quoted 109 lines · Alex Williamson
Quoted 106 lines · On Thu, 22 Oct 2020 16:41:54 +0530 Kirti Wankhede <[email protected]> wrote:
Whether the VFIO device supports migration or not is decided based of migration region query. If migration region query is successful and migration region initialization is successful then migration is supported else migration is blocked.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/meson.build | 1 + hw/vfio/migration.c | 129 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + include/hw/vfio/vfio-common.h | 9 +++ 4 files changed, 142 insertions(+)create mode 100644
hw/vfio/migration.chw/vfio/meson.build +1
-0@@ -2,6 +2,7 @@ vfio_ss = ss.source_set() vfio_ss.add(files( 'common.c', 'spapr.c', + 'migration.c', )) vfio_ss.add(when: 'CONFIG_VFIO_PCI', if_true: files( 'display.c',hw/vfio/migration.c new file +72
-0@@ -0,0 +1,129 @@ +/* +* Migration support for VFIO devices +* +* Copyright NVIDIA, Inc. 2020 +* +* This work is licensed under the terms of the GNU GPL, version 2. See +* the COPYING file in the top-level directory. +*/ + +#include "qemu/osdep.h" +#include <linux/vfio.h> + +#include "hw/vfio/vfio-common.h" +#include "cpu.h" +#include "migration/migration.h" +#include "migration/qemu-file.h" +#include "migration/register.h" +#include "migration/blocker.h" +#include "migration/misc.h" +#include "qapi/error.h" +#include "exec/ramlist.h" +#include "exec/ram_addr.h" +#include "pci.h" +#include "trace.h" + +static void vfio_migration_region_exit (VFIODevice *vbasedev) +{ +VFIOMigration *migration = vbasedev->migration; + +if (!migration) { +return ; + } + +if (migration->region.size) { +vfio_region_exit (&migration->region); +vfio_region_finalize (&migration->region); + } +} + +static int vfio_migration_init (VFIODevice *vbasedev, +struct vfio_region_info *info) +{ +int ret; +Object *obj; +VFIOMigration *migration; + +if (!vbasedev->ops->vfio_get_object) { +return -EINVAL ; + } + + obj = vbasedev->ops->vfio_get_object (vbasedev); +if (!obj) { +return -EINVAL ; + } + + migration =g_new0 (VFIOMigration,1 ); + + ret =vfio_region_setup (obj, vbasedev, &migration->region, + info->index,"migration" ); +if (ret) { +error_report ("%s: Failed to setup VFIO migration region %d: %s" , + vbasedev->name, info->index,strerror (-ret)); + goto err; + } + +if (!migration->region.size) { +error_report ("%s: Invalid zero-sized of VFIO migration region %d" , + vbasedev->name, info->index); + ret = -EINVAL ; + goto err; + } +
Quoted 9 lines
hw/vfio/migration.c line 77
Quoted 5 lines
hw/vfio/migration.c new file +5
-0+ vbasedev->migration = migration; +return 0 ; + +err: +vfio_migration_region_exit (vbasedev);We can't get here with
vbasedev->migrationset, did you intend to setvbasedev->migrationbefore testing region.size? Thanks,
Oh yes, I missed to address this when I moved migration variable to VFIODevice. Moving vbasedev->migration before region.size check.
Also removing region.size check vfio_migration_region_exit() for vfio_region_exit() and vfio_region_finalize().
Thanks,
Kirti
Quoted 100 lines
Alex
Quoted 95 lines
hw/vfio/migration.c new file +52
-0+g_free (migration); +return ret; +} + +/* ---------------------------------------------------------------------- */ + +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) +{ +struct vfio_region_info *info =NULL ; +Error *local_err =NULL ; +int ret; + + ret =vfio_get_dev_region_info (vbasedev,VFIO_REGION_TYPE_MIGRATION , +VFIO_REGION_SUBTYPE_MIGRATION , &info); +if (ret) { + goto add_blocker; + } + + ret =vfio_migration_init (vbasedev, info); +if (ret) { + goto add_blocker; + } + +g_free (info); +trace_vfio_migration_probe (vbasedev->name, info->index); +return 0 ; + +add_blocker: +error_setg (&vbasedev->migration_blocker, +"VFIO device doesn't support migration" ); +g_free (info); + + ret =migrate_add_blocker (vbasedev->migration_blocker, &local_err); +if (local_err) { +error_propagate (errp, local_err); +error_free (vbasedev->migration_blocker); + vbasedev->migration_blocker =NULL ; + } +return ret; +} + +void vfio_migration_finalize (VFIODevice *vbasedev) +{ +if (vbasedev->migration_blocker) { +migrate_del_blocker (vbasedev->migration_blocker); +error_free (vbasedev->migration_blocker); + vbasedev->migration_blocker =NULL ; + } + +vfio_migration_region_exit (vbasedev); +g_free (vbasedev->migration); +}hw/vfio/trace-events +3
-0@@ -145,3 +145,6 @@ vfio_display_edid_link_up(void) "" vfio_display_edid_link_down(void) "" vfio_display_edid_update(uint32_t prefx, uint32_t prefy) "%ux%u" vfio_display_edid_write_error(void) "" + +# migration.c +vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d"include/hw/vfio/vfio-common.h +9
-0@@ -57,6 +57,10 @@ typedef struct VFIORegion {uint8_t nr;/* cache the region number for debug */ } VFIORegion; +typedef struct VFIOMigration { +VFIORegion region; +}VFIOMigration ; + typedef struct VFIOAddressSpace { AddressSpace *as; QLIST_HEAD(, VFIOContainer) containers;@@ -113,6 +117,8 @@ typedef struct VFIODevice {unsigned int num_irqs;unsigned int num_regions;unsigned int flags; +VFIOMigration *migration; +Error *migration_blocker; } VFIODevice;struct VFIODeviceOps {@@ -204,4 +210,7 @@ int vfio_spapr_create_window(VFIOContainer *container,int vfio_spapr_remove_window (VFIOContainer *container,hwaddr offset_within_address_space); +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp); +void vfio_migration_finalize (VFIODevice *vbasedev); +#endif /* HW_VFIO_VFIO_COMMON_H */
Re: [PATCH v27 04/17] vfio: Add migration region initialization and finalize function
In reply to Kirti WankhedeQuoted 15 lines · On Thu, 22 Oct 2020 16:41:54 +0530 Kirti Wankhede <[email protected]> wrote:
Whether the VFIO device supports migration or not is decided based of migration region query. If migration region query is successful and migration region initialization is successful then migration is supported else migration is blocked.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/meson.build | 1 + hw/vfio/migration.c | 129 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + include/hw/vfio/vfio-common.h | 9 +++ 4 files changed, 142 insertions(+) create mode 100644 hw/vfio/migration.c
(...)
Quoted 18 lines
hw/vfio/migration.c new file +18
-0+static int vfio_migration_init (VFIODevice *vbasedev, +struct vfio_region_info *info) +{ +int ret; +Object *obj; +VFIOMigration *migration; + +if (!vbasedev->ops->vfio_get_object) { +return -EINVAL ; + } + + obj = vbasedev->ops->vfio_get_object (vbasedev); +if (!obj) { +return -EINVAL ; + } + + migration =g_new0 (VFIOMigration,1 ); +
hw/vfio/migration.c line 67
Quoted 10 lines
hw/vfio/migration.c new file +10
-0+ ret =vfio_region_setup (obj, vbasedev, &migration->region, + info->index,"migration" ); +if (ret) { +error_report ("%s: Failed to setup VFIO migration region %d: %s" , + vbasedev->name, info->index,strerror (-ret)); + goto err; + } + +if (!migration->region.size) { + error_report("%s: Invalid zero-sized of VFIO migration region %d",
s/of //
Quoted 13 lines
hw/vfio/migration.c new file +13
-0+ vbasedev->name, info->index); + ret = -EINVAL ; + goto err; + } + + vbasedev->migration = migration; +return 0 ; + +err: +vfio_migration_region_exit (vbasedev); +g_free (migration); +return ret; +}
(...)
PATCH v27 5/17 vfio: Add VM state change handler to know state of VM
In reply to Kirti WankhedeVM state change handler is called on change in VM's state. Based on VM state, VFIO device state should be changed.
Added read/write helper functions for migration region. Added function to set device_state.
--- hw/vfio/migration.c | 158 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 + include/hw/vfio/vfio-common.h | 4 ++ 3 files changed, 164 insertions(+)
hw/vfio/migration.c +158 -0
@@ -10,6 +10,7 @@#include "qemu/osdep.h" #include <linux/vfio.h> +#include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h"
@@ -22,6 +23,157 @@#include "exec/ram_addr.h" #include "pci.h" #include "trace.h" +#include "hw/hw.h" + +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count, +off_t off,bool iswrite) +{ +int ret; + + ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : +pread (vbasedev->fd, val, count, off); +if (ret < count) { +error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%lx, err: %s" , + iswrite ?"write" :"read" , count, + vbasedev->name, off,strerror (errno)); +return (ret <0 ) ? ret : -EINVAL ; + } +return 0 ; +} + +static int vfio_mig_rw (VFIODevice *vbasedev,__u8 *buf,size_t count, +off_t off,bool iswrite) +{ +int ret, done =0 ; +__u8 *tbuf = buf; + +while (count) { +int bytes =0 ; + +if (count >=8 && !(off %8 )) { + bytes =8 ; + }else if (count >=4 && !(off %4 )) { + bytes =4 ; + }else if (count >=2 && !(off %2 )) { + bytes =2 ; + }else { + bytes =1 ; + } + + ret =vfio_mig_access (vbasedev, tbuf, bytes, off, iswrite); +if (ret) { +return ret; + } + + count -= bytes; + done += bytes; + off += bytes; + tbuf += bytes; + } +return done; +} + +#define vfio_mig_read (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, false) +#define vfio_mig_write (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, true) + +#define VFIO_MIG_STRUCT_OFFSET (f) \ + offsetof(struct vfio_device_migration_info, f) +/* +* Change the device_state register for device @vbasedev. Bits set in @mask +* are preserved, bits set in @value are set, and bits not set in either @mask +* or @value are cleared in device_state. If the register cannot be accessed, +* the resulting state would be invalid, or the device enters an error state, +* an error is returned. +*/ + +static int vfio_migration_set_state (VFIODevice *vbasedev,uint32_t mask, +uint32_t value) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +off_t dev_state_off = region->fd_offset + +VFIO_MIG_STRUCT_OFFSET (device_state); +uint32_t device_state; +int ret; + + ret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +return ret; + } + + device_state = (device_state & mask) | value; + +if (!VFIO_DEVICE_STATE_VALID (device_state)) { +return -EINVAL ; + } + + ret =vfio_mig_write (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +int rret; + + rret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); + +if ((rret <0 ) || (VFIO_DEVICE_STATE_IS_ERROR (device_state))) { +hw_error ("%s: Device in error state 0x%x" , vbasedev->name, + device_state); +return rret ? rret : -EIO ; + } +return ret; + } + + migration->device_state = device_state; +trace_vfio_migration_set_state (vbasedev->name, device_state); +return 0 ; +} + +static void vfio_vmstate_change (void *opaque,int running,RunState state) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint32_t value, mask; +int ret; + +if ((vbasedev->migration->vm_running == running)) { +return ; + } + +if (running) { +/* +* Here device state can have one of _SAVING, _RESUMING or _STOP bit. +* Transition from _SAVING to _RUNNING can happen if there is migration +* failure, in that case clear _SAVING bit. +* Transition from _RESUMING to _RUNNING occurs during resuming +* phase, in that case clear _RESUMING bit. +* In both the above cases, set _RUNNING bit. +*/ + mask = ~VFIO_DEVICE_STATE_MASK ; + value =VFIO_DEVICE_STATE_RUNNING ; + }else { +/* +* Here device state could be either _RUNNING or _SAVING|_RUNNING. Reset +* _RUNNING bit +*/ + mask = ~VFIO_DEVICE_STATE_RUNNING ; + value =0 ; + } + + ret =vfio_migration_set_state (vbasedev, mask, value); +if (ret) { +/* +* Migration should be aborted in this case, but vm_state_notify() +* currently does not support reporting failures. +*/ +error_report ("%s: Failed to set device state 0x%x" , vbasedev->name, + (migration->device_state & mask) | value); +qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); + } + vbasedev->migration->vm_running = running; +trace_vfio_vmstate_change (vbasedev->name, running,RunState_str (state), + (migration->device_state & mask) | value); +}static void vfio_migration_region_exit (VFIODevice *vbasedev) {
@@ -71,6 +223,8 @@ static int vfio_migration_init(VFIODevice *vbasedev, } vbasedev->migration = migration; + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, + vbasedev);return 0 ; err:
@@ -118,6 +272,10 @@ add_blocker:void vfio_migration_finalize (VFIODevice *vbasedev) { +if (vbasedev->migration->vm_state) { +qemu_del_vm_change_state_handler (vbasedev->migration->vm_state); + } +if (vbasedev->migration_blocker) {migrate_del_blocker (vbasedev->migration_blocker);error_free (vbasedev->migration_blocker);
hw/vfio/trace-events +2 -0
@@ -148,3 +148,5 @@ vfio_display_edid_write_error(void) "" # migration.c vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" +vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" +vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d"
include/hw/vfio/vfio-common.h +4 -0
@@ -29,6 +29,7 @@#ifdef CONFIG_LINUX #include <linux/vfio.h> #endif +#include "sysemu/sysemu.h" #define VFIO_MSG_PREFIX "vfio %s: "
@@ -58,7 +59,10 @@ typedef struct VFIORegion { } VFIORegion;typedef struct VFIOMigration { +VMChangeStateEntry *vm_state;VFIORegion region; +uint32_t device_state; +int vm_running; }VFIOMigration ; typedef struct VFIOAddressSpace {
Signature · 1 line
2.7.0
Re: [PATCH v27 05/17] vfio: Add VM state change handler to know state of VM
Quoted 194 lines · On Thu, 22 Oct 2020 16:41:55 +0530 Kirti Wankhede <[email protected]> wrote:
VM state change handler is called on change in VM's state. Based on VM state, VFIO device state should be changed.
Added read/write helper functions for migration region. Added function to setdevice_state.Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/migration.c | 158 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 + include/hw/vfio/vfio-common.h | 4 ++ 3 files changed, 164 insertions(+)hw/vfio/migration.c +154
-0@@ -10,6 +10,7 @@#include "qemu/osdep.h" #include <linux/vfio.h> +#include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" @@ -22,6 +23,157 @@#include "exec/ram_addr.h" #include "pci.h" #include "trace.h" +#include "hw/hw.h" + +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count, +off_t off,bool iswrite) +{ +int ret; + + ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : +pread (vbasedev->fd, val, count, off); +if (ret < count) { +error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%lx, err: %s" , + iswrite ?"write" :"read" , count, + vbasedev->name, off,strerror (errno)); +return (ret <0 ) ? ret : -EINVAL ; + } +return 0 ; +} + +static int vfio_mig_rw (VFIODevice *vbasedev,__u8 *buf,size_t count, +off_t off,bool iswrite) +{ +int ret, done =0 ; +__u8 *tbuf = buf; + +while (count) { +int bytes =0 ; + +if (count >=8 && !(off %8 )) { + bytes =8 ; + }else if (count >=4 && !(off %4 )) { + bytes =4 ; + }else if (count >=2 && !(off %2 )) { + bytes =2 ; + }else { + bytes =1 ; + } + + ret =vfio_mig_access (vbasedev, tbuf, bytes, off, iswrite); +if (ret) { +return ret; + } + + count -= bytes; + done += bytes; + off += bytes; + tbuf += bytes; + } +return done; +} + +#define vfio_mig_read (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, false) +#define vfio_mig_write (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, true) + +#define VFIO_MIG_STRUCT_OFFSET (f) \ + offsetof(struct vfio_device_migration_info, f) +/* +* Change the device_state register for device @vbasedev. Bits set in @mask +* are preserved, bits set in @value are set, and bits not set in either @mask +* or @value are cleared in device_state. If the register cannot be accessed, +* the resulting state would be invalid, or the device enters an error state, +* an error is returned. +*/ + +static int vfio_migration_set_state (VFIODevice *vbasedev,uint32_t mask, +uint32_t value) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +off_t dev_state_off = region->fd_offset + +VFIO_MIG_STRUCT_OFFSET (device_state); +uint32_t device_state; +int ret; + + ret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +return ret; + } + + device_state = (device_state & mask) | value; + +if (!VFIO_DEVICE_STATE_VALID (device_state)) { +return -EINVAL ; + } + + ret =vfio_mig_write (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +int rret; + + rret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); + +if ((rret <0 ) || (VFIO_DEVICE_STATE_IS_ERROR (device_state))) { +hw_error ("%s: Device in error state 0x%x" , vbasedev->name, + device_state); +return rret ? rret : -EIO ; + } +return ret; + } + + migration->device_state = device_state; +trace_vfio_migration_set_state (vbasedev->name, device_state); +return 0 ; +} + +static void vfio_vmstate_change (void *opaque,int running,RunState state) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint32_t value, mask; +int ret; + +if ((vbasedev->migration->vm_running == running)) { +return ; + } + +if (running) { +/* +* Here device state can have one of _SAVING, _RESUMING or _STOP bit. +* Transition from _SAVING to _RUNNING can happen if there is migration +* failure, in that case clear _SAVING bit. +* Transition from _RESUMING to _RUNNING occurs during resuming +* phase, in that case clear _RESUMING bit. +* In both the above cases, set _RUNNING bit. +*/ + mask = ~VFIO_DEVICE_STATE_MASK ; + value =VFIO_DEVICE_STATE_RUNNING ; + }else { +/* +* Here device state could be either _RUNNING or _SAVING|_RUNNING. Reset +* _RUNNING bit +*/ + mask = ~VFIO_DEVICE_STATE_RUNNING ; + value =0 ; + } + + ret =vfio_migration_set_state (vbasedev, mask, value); +if (ret) { +/* +* Migration should be aborted in this case, but vm_state_notify() +* currently does not support reporting failures. +*/ +error_report ("%s: Failed to set device state 0x%x" , vbasedev->name, + (migration->device_state & mask) | value); +qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); + } + vbasedev->migration->vm_running = running; +trace_vfio_vmstate_change (vbasedev->name, running,RunState_str (state), + (migration->device_state & mask) | value); +}static void vfio_migration_region_exit (VFIODevice *vbasedev) {@@ -71,6 +223,8 @@ static int vfio_migration_init(VFIODevice *vbasedev, } vbasedev->migration = migration; + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, + vbasedev);return 0 ; err:
hw/vfio/migration.c add_blocker: · line 277
Quoted 6 lines
hw/vfio/migration.c +3
-0@@ -118,6 +272,10 @@ add_blocker:void vfio_migration_finalize (VFIODevice *vbasedev) { +if (vbasedev->migration->vm_state) { +qemu_del_vm_change_state_handler (vbasedev->migration->vm_state); + }
This looks like a segfault, vfio_migration_teardown() is eventually called unconditionally. The next patch modifies this function further, but never checks that vbasedev->migration is non-NULL. Thanks,
Alex
Quoted 37 lines
hw/vfio/migration.c +1
-0+if (vbasedev->migration_blocker) {migrate_del_blocker (vbasedev->migration_blocker);error_free (vbasedev->migration_blocker);hw/vfio/trace-events +2
-0@@ -148,3 +148,5 @@ vfio_display_edid_write_error(void) "" # migration.c vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" +vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" +vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d"include/hw/vfio/vfio-common.h +4
-0@@ -29,6 +29,7 @@#ifdef CONFIG_LINUX #include <linux/vfio.h> #endif +#include "sysemu/sysemu.h" #define VFIO_MSG_PREFIX "vfio %s: "@@ -58,7 +59,10 @@ typedef struct VFIORegion { } VFIORegion;typedef struct VFIOMigration { +VMChangeStateEntry *vm_state;VFIORegion region; +uint32_t device_state; +int vm_running; }VFIOMigration ; typedef struct VFIOAddressSpace {
Re: [PATCH v27 05/17] vfio: Add VM state change handler to know state of VM
Quoted 198 lines · Alex Williamson
Quoted 195 lines · On Thu, 22 Oct 2020 16:41:55 +0530 Kirti Wankhede <[email protected]> wrote:
VM state change handler is called on change in VM's state. Based on VM state, VFIO device state should be changed.
Added read/write helper functions for migration region. Added function to setdevice_state.Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/migration.c | 158 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 + include/hw/vfio/vfio-common.h | 4 ++ 3 files changed, 164 insertions(+)hw/vfio/migration.c +154
-0@@ -10,6 +10,7 @@#include "qemu/osdep.h" #include <linux/vfio.h> +#include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" @@ -22,6 +23,157 @@#include "exec/ram_addr.h" #include "pci.h" #include "trace.h" +#include "hw/hw.h" + +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count, +off_t off,bool iswrite) +{ +int ret; + + ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : +pread (vbasedev->fd, val, count, off); +if (ret < count) { +error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%lx, err: %s" , + iswrite ?"write" :"read" , count, + vbasedev->name, off,strerror (errno)); +return (ret <0 ) ? ret : -EINVAL ; + } +return 0 ; +} + +static int vfio_mig_rw (VFIODevice *vbasedev,__u8 *buf,size_t count, +off_t off,bool iswrite) +{ +int ret, done =0 ; +__u8 *tbuf = buf; + +while (count) { +int bytes =0 ; + +if (count >=8 && !(off %8 )) { + bytes =8 ; + }else if (count >=4 && !(off %4 )) { + bytes =4 ; + }else if (count >=2 && !(off %2 )) { + bytes =2 ; + }else { + bytes =1 ; + } + + ret =vfio_mig_access (vbasedev, tbuf, bytes, off, iswrite); +if (ret) { +return ret; + } + + count -= bytes; + done += bytes; + off += bytes; + tbuf += bytes; + } +return done; +} + +#define vfio_mig_read (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, false) +#define vfio_mig_write (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, true) + +#define VFIO_MIG_STRUCT_OFFSET (f) \ + offsetof(struct vfio_device_migration_info, f) +/* +* Change the device_state register for device @vbasedev. Bits set in @mask +* are preserved, bits set in @value are set, and bits not set in either @mask +* or @value are cleared in device_state. If the register cannot be accessed, +* the resulting state would be invalid, or the device enters an error state, +* an error is returned. +*/ + +static int vfio_migration_set_state (VFIODevice *vbasedev,uint32_t mask, +uint32_t value) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +off_t dev_state_off = region->fd_offset + +VFIO_MIG_STRUCT_OFFSET (device_state); +uint32_t device_state; +int ret; + + ret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +return ret; + } + + device_state = (device_state & mask) | value; + +if (!VFIO_DEVICE_STATE_VALID (device_state)) { +return -EINVAL ; + } + + ret =vfio_mig_write (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +int rret; + + rret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); + +if ((rret <0 ) || (VFIO_DEVICE_STATE_IS_ERROR (device_state))) { +hw_error ("%s: Device in error state 0x%x" , vbasedev->name, + device_state); +return rret ? rret : -EIO ; + } +return ret; + } + + migration->device_state = device_state; +trace_vfio_migration_set_state (vbasedev->name, device_state); +return 0 ; +} + +static void vfio_vmstate_change (void *opaque,int running,RunState state) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint32_t value, mask; +int ret; + +if ((vbasedev->migration->vm_running == running)) { +return ; + } + +if (running) { +/* +* Here device state can have one of _SAVING, _RESUMING or _STOP bit. +* Transition from _SAVING to _RUNNING can happen if there is migration +* failure, in that case clear _SAVING bit. +* Transition from _RESUMING to _RUNNING occurs during resuming +* phase, in that case clear _RESUMING bit. +* In both the above cases, set _RUNNING bit. +*/ + mask = ~VFIO_DEVICE_STATE_MASK ; + value =VFIO_DEVICE_STATE_RUNNING ; + }else { +/* +* Here device state could be either _RUNNING or _SAVING|_RUNNING. Reset +* _RUNNING bit +*/ + mask = ~VFIO_DEVICE_STATE_RUNNING ; + value =0 ; + } + + ret =vfio_migration_set_state (vbasedev, mask, value); +if (ret) { +/* +* Migration should be aborted in this case, but vm_state_notify() +* currently does not support reporting failures. +*/ +error_report ("%s: Failed to set device state 0x%x" , vbasedev->name, + (migration->device_state & mask) | value); +qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); + } + vbasedev->migration->vm_running = running; +trace_vfio_vmstate_change (vbasedev->name, running,RunState_str (state), + (migration->device_state & mask) | value); +}static void vfio_migration_region_exit (VFIODevice *vbasedev) {@@ -71,6 +223,8 @@ static int vfio_migration_init(VFIODevice *vbasedev, } vbasedev->migration = migration; + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, + vbasedev);return 0 ; err:@@ -118,6 +272,10 @@ add_blocker:
Quoted 11 lines
hw/vfio/migration.c add_blocker: · line 277
Quoted 5 lines
hw/vfio/migration.c +3
-0void vfio_migration_finalize (VFIODevice *vbasedev) { +if (vbasedev->migration->vm_state) { +qemu_del_vm_change_state_handler (vbasedev->migration->vm_state); + }This looks like a segfault,
vfio_migration_teardown()is eventually called unconditionally. The next patch modifies this function further, but never checks thatvbasedev->migrationis non-NULL. Thanks,
Yup.
Updated patch 4, 5 and 6. So now vfio_migration_finalize() looks like:
void vfio_migration_finalize(VFIODevice *vbasedev)
{
VFIOMigration *migration = vbasedev->migration;
if (migration) {
if (migration->migration_state.notify) {remove_migration_state_change_notifier(&migration->migration_state);
}
if (migration->vm_state) {
qemu_del_vm_change_state_handler(migration->vm_state);
}
vfio_migration_region_exit(vbasedev);
g_free(vbasedev->migration);
vbasedev->migration = NULL;
}
if (vbasedev->migration_blocker) {
migrate_del_blocker(vbasedev->migration_blocker);
error_free(vbasedev->migration_blocker);
vbasedev->migration_blocker = NULL;
}
}Thanks,
Kirti
Quoted 41 lines
Alex
Quoted 37 lines
hw/vfio/migration.c +1
-0+if (vbasedev->migration_blocker) {migrate_del_blocker (vbasedev->migration_blocker);error_free (vbasedev->migration_blocker);hw/vfio/trace-events +2
-0@@ -148,3 +148,5 @@ vfio_display_edid_write_error(void) "" # migration.c vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" +vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" +vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d"include/hw/vfio/vfio-common.h +4
-0@@ -29,6 +29,7 @@#ifdef CONFIG_LINUX #include <linux/vfio.h> #endif +#include "sysemu/sysemu.h" #define VFIO_MSG_PREFIX "vfio %s: "@@ -58,7 +59,10 @@ typedef struct VFIORegion { } VFIORegion;typedef struct VFIOMigration { +VMChangeStateEntry *vm_state;VFIORegion region; +uint32_t device_state; +int vm_running; }VFIOMigration ; typedef struct VFIOAddressSpace {
Re: [PATCH v27 05/17] vfio: Add VM state change handler to know state of VM
Quoted 221 lines · On Thu, 22 Oct 2020 23:11:39 +0530 Kirti Wankhede <[email protected]> wrote:
Quoted 198 lines · Alex Williamson
Quoted 195 lines · On Thu, 22 Oct 2020 16:41:55 +0530 Kirti Wankhede <[email protected]> wrote:
VM state change handler is called on change in VM's state. Based on VM state, VFIO device state should be changed.
Added read/write helper functions for migration region. Added function to setdevice_state.Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/migration.c | 158 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 + include/hw/vfio/vfio-common.h | 4 ++ 3 files changed, 164 insertions(+)hw/vfio/migration.c +154
-0@@ -10,6 +10,7 @@#include "qemu/osdep.h" #include <linux/vfio.h> +#include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" @@ -22,6 +23,157 @@#include "exec/ram_addr.h" #include "pci.h" #include "trace.h" +#include "hw/hw.h" + +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count, +off_t off,bool iswrite) +{ +int ret; + + ret = iswrite ?pwrite (vbasedev->fd, val, count, off) : +pread (vbasedev->fd, val, count, off); +if (ret < count) { +error_report ("vfio_mig_%s %d byte %s: failed at offset 0x%lx, err: %s" , + iswrite ?"write" :"read" , count, + vbasedev->name, off,strerror (errno)); +return (ret <0 ) ? ret : -EINVAL ; + } +return 0 ; +} + +static int vfio_mig_rw (VFIODevice *vbasedev,__u8 *buf,size_t count, +off_t off,bool iswrite) +{ +int ret, done =0 ; +__u8 *tbuf = buf; + +while (count) { +int bytes =0 ; + +if (count >=8 && !(off %8 )) { + bytes =8 ; + }else if (count >=4 && !(off %4 )) { + bytes =4 ; + }else if (count >=2 && !(off %2 )) { + bytes =2 ; + }else { + bytes =1 ; + } + + ret =vfio_mig_access (vbasedev, tbuf, bytes, off, iswrite); +if (ret) { +return ret; + } + + count -= bytes; + done += bytes; + off += bytes; + tbuf += bytes; + } +return done; +} + +#define vfio_mig_read (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, false) +#define vfio_mig_write (f, v, c, o) vfio_mig_rw(f, (__u8 *)v, c, o, true) + +#define VFIO_MIG_STRUCT_OFFSET (f) \ + offsetof(struct vfio_device_migration_info, f) +/* +* Change the device_state register for device @vbasedev. Bits set in @mask +* are preserved, bits set in @value are set, and bits not set in either @mask +* or @value are cleared in device_state. If the register cannot be accessed, +* the resulting state would be invalid, or the device enters an error state, +* an error is returned. +*/ + +static int vfio_migration_set_state (VFIODevice *vbasedev,uint32_t mask, +uint32_t value) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +off_t dev_state_off = region->fd_offset + +VFIO_MIG_STRUCT_OFFSET (device_state); +uint32_t device_state; +int ret; + + ret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +return ret; + } + + device_state = (device_state & mask) | value; + +if (!VFIO_DEVICE_STATE_VALID (device_state)) { +return -EINVAL ; + } + + ret =vfio_mig_write (vbasedev, &device_state,sizeof (device_state), + dev_state_off); +if (ret <0 ) { +int rret; + + rret =vfio_mig_read (vbasedev, &device_state,sizeof (device_state), + dev_state_off); + +if ((rret <0 ) || (VFIO_DEVICE_STATE_IS_ERROR (device_state))) { +hw_error ("%s: Device in error state 0x%x" , vbasedev->name, + device_state); +return rret ? rret : -EIO ; + } +return ret; + } + + migration->device_state = device_state; +trace_vfio_migration_set_state (vbasedev->name, device_state); +return 0 ; +} + +static void vfio_vmstate_change (void *opaque,int running,RunState state) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint32_t value, mask; +int ret; + +if ((vbasedev->migration->vm_running == running)) { +return ; + } + +if (running) { +/* +* Here device state can have one of _SAVING, _RESUMING or _STOP bit. +* Transition from _SAVING to _RUNNING can happen if there is migration +* failure, in that case clear _SAVING bit. +* Transition from _RESUMING to _RUNNING occurs during resuming +* phase, in that case clear _RESUMING bit. +* In both the above cases, set _RUNNING bit. +*/ + mask = ~VFIO_DEVICE_STATE_MASK ; + value =VFIO_DEVICE_STATE_RUNNING ; + }else { +/* +* Here device state could be either _RUNNING or _SAVING|_RUNNING. Reset +* _RUNNING bit +*/ + mask = ~VFIO_DEVICE_STATE_RUNNING ; + value =0 ; + } + + ret =vfio_migration_set_state (vbasedev, mask, value); +if (ret) { +/* +* Migration should be aborted in this case, but vm_state_notify() +* currently does not support reporting failures. +*/ +error_report ("%s: Failed to set device state 0x%x" , vbasedev->name, + (migration->device_state & mask) | value); +qemu_file_set_error (migrate_get_current ()->to_dst_file, ret); + } + vbasedev->migration->vm_running = running; +trace_vfio_vmstate_change (vbasedev->name, running,RunState_str (state), + (migration->device_state & mask) | value); +}static void vfio_migration_region_exit (VFIODevice *vbasedev) {@@ -71,6 +223,8 @@ static int vfio_migration_init(VFIODevice *vbasedev, } vbasedev->migration = migration; + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, + vbasedev);return 0 ; err:@@ -118,6 +272,10 @@ add_blocker:Quoted 11 lines
hw/vfio/migration.c add_blocker: · line 277
Quoted 5 lines
hw/vfio/migration.c +3
-0void vfio_migration_finalize (VFIODevice *vbasedev) { +if (vbasedev->migration->vm_state) { +qemu_del_vm_change_state_handler (vbasedev->migration->vm_state); + }This looks like a segfault,
vfio_migration_teardown()is eventually called unconditionally. The next patch modifies this function further, but never checks thatvbasedev->migrationis non-NULL. Thanks,Yup.
Updated patch 4, 5 and 6. So nowvfio_migration_finalize()looks like:void
vfio_migration_finalize(VFIODevice *vbasedev){ VFIOMigration *migration = vbasedev->migration; if (migration) { if (migration->migration_state.notify) {
Quoted 6 lines
remove_migration_state_change_notifier(&migration->migration_state);
}
if (migration->vm_state) {
qemu_del_vm_change_state_handler(migration->vm_state);
}We should be able to remove these based only on migration being non-NULL, their setup cannot fail once we've setup the migration pointer. Thanks,
Alex
Quoted 58 lines
vfio_migration_region_exit(vbasedev); g_free(vbasedev->migration); vbasedev->migration = NULL; } if (vbasedev->migration_blocker) { migrate_del_blocker(vbasedev->migration_blocker); error_free(vbasedev->migration_blocker); vbasedev->migration_blocker = NULL; } }Thanks,
KirtiQuoted 41 lines
Alex
Quoted 37 lines
hw/vfio/migration.c +1
-0+if (vbasedev->migration_blocker) {migrate_del_blocker (vbasedev->migration_blocker);error_free (vbasedev->migration_blocker);hw/vfio/trace-events +2
-0@@ -148,3 +148,5 @@ vfio_display_edid_write_error(void) "" # migration.c vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" +vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" +vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d"include/hw/vfio/vfio-common.h +4
-0@@ -29,6 +29,7 @@#ifdef CONFIG_LINUX #include <linux/vfio.h> #endif +#include "sysemu/sysemu.h" #define VFIO_MSG_PREFIX "vfio %s: "@@ -58,7 +59,10 @@ typedef struct VFIORegion { } VFIORegion;typedef struct VFIOMigration { +VMChangeStateEntry *vm_state;VFIORegion region; +uint32_t device_state; +int vm_running; }VFIOMigration ; typedef struct VFIOAddressSpace {
PATCH v27 6/17 vfio: Add migration state change notifier
In reply to Kirti WankhedeAdded migration state change notifier to get notification on migration state change. These states are translated to VFIO device state and conveyed to vendor driver.
--- hw/vfio/migration.c | 37 +++++++++++++++++++++++++++++++++++-- hw/vfio/trace-events | 1 + include/hw/vfio/vfio-common.h | 2 ++ 3 files changed, 38 insertions(+), 2 deletions(-)
hw/vfio/migration.c +35 -2
@@ -175,6 +175,30 @@ static void vfio_vmstate_change(void *opaque, int running, RunState state) (migration->device_state & mask) | value); } +static void vfio_migration_state_notifier (Notifier *notifier,void *data) +{ +MigrationState *s = data; +VFIOMigration *migration =container_of (notifier, VFIOMigration, + migration_state); +VFIODevice *vbasedev = migration->vbasedev; +int ret; + +trace_vfio_migration_state_notifier (vbasedev->name, +MigrationStatus_str (s->state)); + +switch (s->state) { +case MIGRATION_STATUS_CANCELLING : +case MIGRATION_STATUS_CANCELLED : +case MIGRATION_STATUS_FAILED : + ret =vfio_migration_set_state (vbasedev, + ~(VFIO_DEVICE_STATE_SAVING |VFIO_DEVICE_STATE_RESUMING ), +VFIO_DEVICE_STATE_RUNNING ); +if (ret) { +error_report ("%s: Failed to set state RUNNING" , vbasedev->name); + } + } +} +static void vfio_migration_region_exit (VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration;
@@ -223,8 +247,11 @@ static int vfio_migration_init(VFIODevice *vbasedev, } vbasedev->migration = migration; + migration->vbasedev = vbasedev; migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, vbasedev); + migration->migration_state.notify = vfio_migration_state_notifier; +add_migration_state_change_notifier (&migration->migration_state);return 0 ; err:
@@ -272,8 +299,14 @@ add_blocker:void vfio_migration_finalize (VFIODevice *vbasedev) { -if (vbasedev->migration->vm_state) { -qemu_del_vm_change_state_handler (vbasedev->migration->vm_state); +VFIOMigration *migration = vbasedev->migration; + +if (migration->migration_state.notify) { +remove_migration_state_change_notifier (&migration->migration_state); + } + +if (migration->vm_state) { +qemu_del_vm_change_state_handler (migration->vm_state); }if (vbasedev->migration_blocker) {
hw/vfio/trace-events +1 -0
@@ -150,3 +150,4 @@ vfio_display_edid_write_error(void) "" vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d" +vfio_migration_state_notifier(const char *name, const char *state) " (%s) state %s"
include/hw/vfio/vfio-common.h +2 -0
@@ -59,10 +59,12 @@ typedef struct VFIORegion { } VFIORegion;typedef struct VFIOMigration { +struct VFIODevice *vbasedev;VMChangeStateEntry *vm_state;VFIORegion region;uint32_t device_state;int vm_running; +Notifier migration_state; }VFIOMigration ; typedef struct VFIOAddressSpace {
Signature · 1 line
2.7.0
PATCH v27 7/17 vfio: Register SaveVMHandlers for VFIO device
In reply to Kirti WankhedeDefine flags to be used as delimiter in migration stream for VFIO devices. Added .save_setup and .save_cleanup functions. Map & unmap migration region from these functions at source during saving or pre-copy phase.
Set VFIO device state depending on VM's state. During live migration, VM is running when .save_setup is called, _SAVING | _RUNNING state is set for VFIO device. During save-restore, VM is paused, _SAVING state is set for VFIO device.
--- hw/vfio/migration.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 ++ 2 files changed, 98 insertions(+)
hw/vfio/migration.c +96 -0
@@ -8,12 +8,15 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" +#include "qemu/cutils.h" #include <linux/vfio.h> #include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" +#include "migration/vmstate.h" #include "migration/qemu-file.h" #include "migration/register.h" #include "migration/blocker.h"
@@ -25,6 +28,22 @@#include "trace.h" #include "hw/hw.h" +/* +* Flags to be used as unique delimiters for VFIO devices in the migration +* stream. These flags are composed as: +* 0xffffffff => MSB 32-bit all 1s +* 0xef10 => Magic ID, represents emulated (virtual) function IO +* 0x0000 => 16-bits reserved for flags +* +* The beginning of state information is marked by _DEV_CONFIG_STATE, +* _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a +* certain state information is marked by _END_OF_STATE. +*/ +#define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) +#define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) +#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) +#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {
@@ -129,6 +148,69 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask,return 0 ; } +/* ---------------------------------------------------------------------- */ + +static int vfio_save_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret; + +trace_vfio_save_setup (vbasedev->name); + +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_SETUP_STATE ); + +if (migration->region.mmaps) { +/* +* vfio_region_mmap() called from migration thread. Memory API called +* from vfio_regio_mmap() need it when called from outdide the main loop +* thread. +*/ +qemu_mutex_lock_iothread (); + ret =vfio_region_mmap (&migration->region); +qemu_mutex_unlock_iothread (); +if (ret) { +error_report ("%s: Failed to mmap VFIO migration region: %s" , + vbasedev->name,strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev,VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_SAVING ); +if (ret) { +error_report ("%s: Failed to set state SAVING" , vbasedev->name); +return ret; + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + +return 0 ; +} + +static void vfio_save_cleanup (void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; + +if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + } +trace_vfio_save_cleanup (vbasedev->name); +} + +static SaveVMHandlers savevm_vfio_handlers = { + .save_setup = vfio_save_setup, + .save_cleanup = vfio_save_cleanup, +}; + +/* ---------------------------------------------------------------------- */ +static void vfio_vmstate_change (void *opaque,int running,RunState state) {VFIODevice *vbasedev = opaque;
@@ -219,6 +301,8 @@ static int vfio_migration_init(VFIODevice *vbasedev,int ret;Object *obj;VFIOMigration *migration; +char id[256 ] ="" ; + g_autofree char *path = NULL, *oid;if (!vbasedev->ops->vfio_get_object) {return -EINVAL ;
@@ -248,6 +332,18 @@ static int vfio_migration_init(VFIODevice *vbasedev, vbasedev->migration = migration; migration->vbasedev = vbasedev; + + oid =vmstate_if_get_id (VMSTATE_IF (DEVICE (obj))); +if (oid) { + path =g_strdup_printf ("%s/vfio" , oid); + }else { + path =g_strdup ("vfio" ); + } +strpadcpy (id,sizeof (id), path,'\0' ); + +register_savevm_live (id,VMSTATE_INSTANCE_ID_ANY ,1 , &savevm_vfio_handlers, + vbasedev); + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, vbasedev); migration->migration_state.notify = vfio_migration_state_notifier;
hw/vfio/trace-events +2 -0
@@ -151,3 +151,5 @@ vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d" vfio_migration_state_notifier(const char *name, const char *state) " (%s) state %s" +vfio_save_setup(const char *name) " (%s)" +vfio_save_cleanup(const char *name) " (%s)"
Signature · 1 line
2.7.0
Re: [PATCH v27 07/17] vfio: Register SaveVMHandlers for VFIO device
Quoted 70 lines · On Thu, 22 Oct 2020 16:41:57 +0530 Kirti Wankhede <[email protected]> wrote:
Define flags to be used as delimiter in migration stream for VFIO devices. Added .save_setup and .save_cleanup functions. Map & unmap migration region from these functions at source during saving or pre-copy phase.
Set VFIO device state depending on VM's state. During live migration, VM is running when .save_setup is called,
_SAVING|_RUNNINGstate is set for VFIO device. During save-restore, VM is paused,_SAVINGstate is set for VFIO device.Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/migration.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 ++ 2 files changed, 98 insertions(+)hw/vfio/migration.c +27
-0@@ -8,12 +8,15 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" +#include "qemu/cutils.h" #include <linux/vfio.h> #include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" +#include "migration/vmstate.h" #include "migration/qemu-file.h" #include "migration/register.h" #include "migration/blocker.h" @@ -25,6 +28,22 @@#include "trace.h" #include "hw/hw.h" +/* +* Flags to be used as unique delimiters for VFIO devices in the migration +* stream. These flags are composed as: +* 0xffffffff => MSB 32-bit all 1s +* 0xef10 => Magic ID, represents emulated (virtual) function IO +* 0x0000 => 16-bits reserved for flags +* +* The beginning of state information is marked by _DEV_CONFIG_STATE, +* _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a +* certain state information is marked by _END_OF_STATE. +*/ +#define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) +#define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) +#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) +#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {@@ -129,6 +148,69 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask,return 0 ; } +/* ---------------------------------------------------------------------- */ + +static int vfio_save_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret; +
hw/vfio/migration.c static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, · line 168
Quoted 10 lines
hw/vfio/migration.c +10
-0+trace_vfio_save_setup (vbasedev->name); + +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_SETUP_STATE ); + +if (migration->region.mmaps) { +/* +* vfio_region_mmap() called from migration thread. Memory API called +* from vfio_regio_mmap() need it when called from outdide the main loop +* thread. +*/
Thanks for adding this detail, maybe refine slightly as:
Calling vfio_region_mmap() from migration thread. Memory APIs called from this function require locking the iothread when called from outside the main loop thread.
Does that capture the intent?
Quoted 25 lines
hw/vfio/migration.c +25
-0+qemu_mutex_lock_iothread (); + ret =vfio_region_mmap (&migration->region); +qemu_mutex_unlock_iothread (); +if (ret) { +error_report ("%s: Failed to mmap VFIO migration region: %s" , + vbasedev->name,strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev,VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_SAVING ); +if (ret) { +error_report ("%s: Failed to set state SAVING" , vbasedev->name); +return ret; + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + +return 0 ;
hw/vfio/migration.c static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, · line 203
Quoted 10 lines
hw/vfio/migration.c +10
-0+} + +static void vfio_save_cleanup (void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; + +if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + }
Are we in a different thread context here that we don't need that same iothread locking?
Quoted 14 lines
hw/vfio/migration.c +10
-0+trace_vfio_save_cleanup (vbasedev->name); +} + +static SaveVMHandlers savevm_vfio_handlers = { + .save_setup = vfio_save_setup, + .save_cleanup = vfio_save_cleanup, +}; + +/* ---------------------------------------------------------------------- */ +static void vfio_vmstate_change (void *opaque,int running,RunState state) {VFIODevice *vbasedev = opaque;
hw/vfio/migration.c static int vfio_migration_init(VFIODevice *vbasedev, · line 305
Quoted 5 lines
hw/vfio/migration.c +2
-0@@ -219,6 +301,8 @@ static int vfio_migration_init(VFIODevice *vbasedev,int ret;Object *obj;VFIOMigration *migration; +char id[256 ] ="" ; + g_autofree char *path = NULL, *oid;
AIUI, oid must also be initialized as a g_autofree variable.
hw/vfio/migration.c static int vfio_migration_init(VFIODevice *vbasedev, · line 340
Quoted 13 lines
hw/vfio/migration.c +6
-0if (!vbasedev->ops->vfio_get_object) {return -EINVAL ;@@ -248,6 +332,18 @@ static int vfio_migration_init(VFIODevice *vbasedev, vbasedev->migration = migration; migration->vbasedev = vbasedev; + + oid =vmstate_if_get_id (VMSTATE_IF (DEVICE (obj))); +if (oid) { + path =g_strdup_printf ("%s/vfio" , oid); + }else { + path =g_strdup ("vfio" );
If we get here then all vfio devices have the same id string. Isn't that a problem? Thanks,
Alex
Quoted 19 lines
hw/vfio/migration.c +6
-0+ } +strpadcpy (id,sizeof (id), path,'\0' ); + +register_savevm_live (id,VMSTATE_INSTANCE_ID_ANY ,1 , &savevm_vfio_handlers, + vbasedev); + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, vbasedev); migration->migration_state.notify = vfio_migration_state_notifier;hw/vfio/trace-events +2
-0@@ -151,3 +151,5 @@ vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d" vfio_migration_state_notifier(const char *name, const char *state) " (%s) state %s" +vfio_save_setup(const char *name) " (%s)" +vfio_save_cleanup(const char *name) " (%s)"
Re: [PATCH v27 07/17] vfio: Register SaveVMHandlers for VFIO device
Quoted 86 lines · Alex Williamson
Quoted 70 lines · On Thu, 22 Oct 2020 16:41:57 +0530 Kirti Wankhede <[email protected]> wrote:
Define flags to be used as delimiter in migration stream for VFIO devices. Added .save_setup and .save_cleanup functions. Map & unmap migration region from these functions at source during saving or pre-copy phase.
Set VFIO device state depending on VM's state. During live migration, VM is running when .save_setup is called,
_SAVING|_RUNNINGstate is set for VFIO device. During save-restore, VM is paused,_SAVINGstate is set for VFIO device.Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>--- hw/vfio/migration.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 2 ++ 2 files changed, 98 insertions(+)hw/vfio/migration.c +27
-0@@ -8,12 +8,15 @@*/ #include "qemu/osdep.h" +#include "qemu/main-loop.h" +#include "qemu/cutils.h" #include <linux/vfio.h> #include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h" #include "cpu.h" #include "migration/migration.h" +#include "migration/vmstate.h" #include "migration/qemu-file.h" #include "migration/register.h" #include "migration/blocker.h" @@ -25,6 +28,22 @@#include "trace.h" #include "hw/hw.h" +/* +* Flags to be used as unique delimiters for VFIO devices in the migration +* stream. These flags are composed as: +* 0xffffffff => MSB 32-bit all 1s +* 0xef10 => Magic ID, represents emulated (virtual) function IO +* 0x0000 => 16-bits reserved for flags +* +* The beginning of state information is marked by _DEV_CONFIG_STATE, +* _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a +* certain state information is marked by _END_OF_STATE. +*/ +#define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) +#define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) +#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) +#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {@@ -129,6 +148,69 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask,return 0 ; } +/* ---------------------------------------------------------------------- */ + +static int vfio_save_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret; +hw/vfio/migration.c static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, · line 168
Quoted 10 lines
hw/vfio/migration.c +10
-0+trace_vfio_save_setup (vbasedev->name); + +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_SETUP_STATE ); + +if (migration->region.mmaps) { +/* +* vfio_region_mmap() called from migration thread. Memory API called +* from vfio_regio_mmap() need it when called from outdide the main loop +* thread. +*/ Thanks for adding this detail, maybe refine slightly as:
Quoted 6 lines
Calling
vfio_region_mmap()from migration thread. Memory APIs called from this function require locking the iothread when called from outside the main loop thread.Does that capture the intent?
Ok.
Quoted 31 lines
Quoted 31 lines
hw/vfio/migration.c +31
-0+qemu_mutex_lock_iothread (); + ret =vfio_region_mmap (&migration->region); +qemu_mutex_unlock_iothread (); +if (ret) { +error_report ("%s: Failed to mmap VFIO migration region: %s" , + vbasedev->name,strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev,VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_SAVING ); +if (ret) { +error_report ("%s: Failed to set state SAVING" , vbasedev->name); +return ret; + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + +return 0 ; +} + +static void vfio_save_cleanup (void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration;
Quoted 9 lines
hw/vfio/migration.c static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask, · line 203
Quoted 4 lines
hw/vfio/migration.c +4
-0+ +if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + }Are we in a different thread context here that we don't need that same iothread locking?
qemu_savevm_state_setup() is called without holding iothread lock and qemu_savevm_state_cleanup() is called holding iothread lock, so we don't need lock here.
Quoted 29 lines
Quoted 15 lines
hw/vfio/migration.c +10
-0+trace_vfio_save_cleanup (vbasedev->name); +} + +static SaveVMHandlers savevm_vfio_handlers = { + .save_setup = vfio_save_setup, + .save_cleanup = vfio_save_cleanup, +}; + +/* ---------------------------------------------------------------------- */ +static void vfio_vmstate_change (void *opaque,int running,RunState state) {VFIODevice *vbasedev = opaque;hw/vfio/migration.c static int vfio_migration_init(VFIODevice *vbasedev, · line 305
Quoted 5 lines
hw/vfio/migration.c +2
-0@@ -219,6 +301,8 @@ static int vfio_migration_init(VFIODevice *vbasedev,int ret;Object *obj;VFIOMigration *migration; +char id[256 ] ="" ; + g_autofree char *path = NULL, *oid;AIUI, oid must also be initialized as a
g_autofreevariable.Quoted 5 lines
hw/vfio/migration.c +0
-0if (!vbasedev->ops->vfio_get_object) {return -EINVAL ;@@ -248,6 +332,18 @@ static int vfio_migration_init(VFIODevice *vbasedev,
Quoted 13 lines
hw/vfio/migration.c static int vfio_migration_init(VFIODevice *vbasedev, · line 340
Quoted 8 lines
hw/vfio/migration.c +6
-0vbasedev->migration = migration; migration->vbasedev = vbasedev; + + oid =vmstate_if_get_id (VMSTATE_IF (DEVICE (obj))); +if (oid) { + path =g_strdup_printf ("%s/vfio" , oid); + }else { + path =g_strdup ("vfio" );If we get here then all vfio devices have the same id string. Isn't that a problem? Thanks,
Most of the bus types has get_dev_path() callback implemented which is called from get_id, so there are very less chance to get here. With above change, id string we get looks like '0000:00:04.0/vfio', trace logs below:qemu_loadvm_state_section_startfull 61.942 pid=625231 section_id=0x2f idstr=b'0000:00:04.0/vfio' instance_id=0x0 version_id=0x1
qemu_loadvm_state_section_startfull 1.242 pid=625231 section_id=0x30 idstr=b'0000:00:05.0/vfio' instance_id=0x0 version_id=0x1
where '0000:00:04.0'shows location within guest, so that it gets preserved and used during resume.
In the worst when it is not present, idstr remains same but instance_id changes:
qemu_loadvm_state_section_startfull 54.931 pid=609474 section_id=0x2f idstr=b'vfio' instance_id=0x0 version_id=0x1
qemu_loadvm_state_section_startfull 1.180 pid=609474 section_id=0x30 idstr=b'vfio' instance_id=0x1 version_id=0x1
But there is no other way to know location of the device within guest.
Dave, any suggestions here?
Thanks,
Kirti
Quoted 24 lines
Alex
Quoted 19 lines
hw/vfio/migration.c +6
-0+ } +strpadcpy (id,sizeof (id), path,'\0' ); + +register_savevm_live (id,VMSTATE_INSTANCE_ID_ANY ,1 , &savevm_vfio_handlers, + vbasedev); + migration->vm_state =qemu_add_vm_change_state_handler (vfio_vmstate_change, vbasedev); migration->migration_state.notify = vfio_migration_state_notifier;hw/vfio/trace-events +2
-0@@ -151,3 +151,5 @@ vfio_migration_probe(const char *name, uint32_t index) " (%s) Region %d" vfio_migration_set_state(const char *name, uint32_t state) " (%s) state %d" vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t dev_state) " (%s) running %d reason %s device state %d" vfio_migration_state_notifier(const char *name, const char *state) " (%s) state %s" +vfio_save_setup(const char *name) " (%s)" +vfio_save_cleanup(const char *name) " (%s)"
PATCH v27 8/17 vfio: Add save state functions to SaveVMHandlers
In reply to Kirti WankhedeAdded .save_live_pending, .save_live_iterate and .save_live_complete_precopy functions. These functions handles pre-copy and stop-and-copy phase.
In _SAVING|_RUNNING device state or pre-copy phase:
- read pending_bytes. If pending_bytes > 0, go through below steps.
- read data_offset - indicates kernel driver to write data to staging buffer.
- read data_size - amount of data in bytes written by vendor driver in migration region.
- read data_size bytes of data from data_offset in the migration region.
- Write data packet to file stream as below:
{VFIO_MIG_FLAG_DEV_DATA_STATE, data_size, actual data, VFIO_MIG_FLAG_END_OF_STATE }
In _SAVING device state or stop-and-copy phase
a. read config space of device and save to migration file stream. This
doesn't need to be from vendor driver. Any other special config state from driver can be saved as data in following iteration.
b. read pending_bytes. If pending_bytes > 0, go through below steps. c. read data_offset - indicates kernel driver to write data to staging
buffer.
d. read data_size - amount of data in bytes written by vendor driver in
migration region.
e. read data_size bytes of data from data_offset in the migration region. f. Write data packet as below:
{VFIO_MIG_FLAG_DEV_DATA_STATE, data_size, actual data}
g. iterate through steps b to f while (pending_bytes > 0)
h. Write {VFIO_MIG_FLAG_END_OF_STATE}
When data region is mapped, its user's responsibility to read data from data_offset of data_size before moving to next steps.
Includes
Fix Reported-by: Zhi Wang <[email protected]>
https://www.mail-archive.com/[email protected]/msg743722.htm
--- hw/vfio/migration.c | 276 ++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 6 + include/hw/vfio/vfio-common.h | 1 + 3 files changed, 283 insertions(+)
hw/vfio/migration.c +276 -0
@@ -148,6 +148,151 @@ static int vfio_migration_set_state(VFIODevice *vbasedev, uint32_t mask,return 0 ; } +static void *get_data_section_size (VFIORegion *region,uint64_t data_offset, +uint64_t data_size,uint64_t *size) +{ +void *ptr =NULL ; +uint64_t limit =0 ; +int i; + +if (!region->mmaps) { +if (size) { + *size =MIN (data_size, region->size - data_offset); + } +return ptr; + } + +for (i =0 ; i < region->nr_mmaps; i++) { +VFIOMmap *map = region->mmaps + i; + +if ((data_offset >= map->offset) && + (data_offset < map->offset + map->size)) { + +/* check if data_offset is within sparse mmap areas */ + ptr = map->mmap + data_offset - map->offset; +if (size) { + *size =MIN (data_size, map->offset + map->size - data_offset); + } +break ; + }else if ((data_offset < map->offset) && + (!limit || limit > map->offset)) { +/* +* data_offset is not within sparse mmap areas, find size of +* non-mapped area. Check through all list since region->mmaps list +* is not sorted. +*/ + limit = map->offset; + } + } + +if (!ptr && size) { + *size = limit ?MIN (data_size, limit - data_offset) : data_size; + } +return ptr; +} + +static int vfio_save_buffer (QEMUFile *f,VFIODevice *vbasedev,uint64_t *size) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +uint64_t data_offset =0 , data_size =0 , sz; +int ret; + + ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +if (ret <0 ) { +return ret; + } + + ret =vfio_mig_read (vbasedev, &data_size,sizeof (data_size), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +if (ret <0 ) { +return ret; + } + +trace_vfio_save_buffer (vbasedev->name, data_offset, data_size, + migration->pending_bytes); + +qemu_put_be64 (f, data_size); + sz = data_size; + +while (sz) { +void *buf; +uint64_t sec_size; +bool buf_allocated = false; + + buf =get_data_section_size (region, data_offset, sz, &sec_size); + +if (!buf) { + buf =g_try_malloc (sec_size); +if (!buf) { +error_report ("%s: Error allocating buffer " , __func__); +return -ENOMEM ; + } + buf_allocated = true; + + ret =vfio_mig_read (vbasedev, buf, sec_size, + region->fd_offset + data_offset); +if (ret <0 ) { +g_free (buf); +return ret; + } + } + +qemu_put_buffer (f, buf, sec_size); + +if (buf_allocated) { +g_free (buf); + } + sz -= sec_size; + data_offset += sec_size; + } + + ret =qemu_file_get_error (f); + +if (!ret && size) { + *size = data_size; + } + +return ret; +} + +static int vfio_update_pending (VFIODevice *vbasedev) +{ +VFIOMigration *migration = vbasedev->migration; +VFIORegion *region = &migration->region; +uint64_t pending_bytes =0 ; +int ret; + + ret =vfio_mig_read (vbasedev, &pending_bytes,sizeof (pending_bytes), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (pending_bytes)); +if (ret <0 ) { + migration->pending_bytes =0 ; +return ret; + } + + migration->pending_bytes = pending_bytes; +trace_vfio_update_pending (vbasedev->name, pending_bytes); +return 0 ; +} + +static int vfio_save_device_config_state (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; + +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_CONFIG_STATE ); + +if (vbasedev->ops && vbasedev->ops->vfio_save_config) { + vbasedev->ops->vfio_save_config (vbasedev, f); + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + +trace_vfio_save_device_config_state (vbasedev->name); + +return qemu_file_get_error (f); +} +/* ---------------------------------------------------------------------- */ static int vfio_save_setup (QEMUFile *f,void *opaque)
@@ -204,9 +349,140 @@ static void vfio_save_cleanup(void *opaque)trace_vfio_save_cleanup (vbasedev->name); } +static void vfio_save_pending (QEMUFile *f,void *opaque, +uint64_t threshold_size, +uint64_t *res_precopy_only, +uint64_t *res_compatible, +uint64_t *res_postcopy_only) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret; + + ret =vfio_update_pending (vbasedev); +if (ret) { +return ; + } + + *res_precopy_only += migration->pending_bytes; + +trace_vfio_save_pending (vbasedev->name, *res_precopy_only, + *res_postcopy_only, *res_compatible); +} + +static int vfio_save_iterate (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint64_t data_size; +int ret; + +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_DATA_STATE ); + +if (migration->pending_bytes ==0 ) { + ret =vfio_update_pending (vbasedev); +if (ret) { +return ret; + } + +if (migration->pending_bytes ==0 ) { +qemu_put_be64 (f,0 ); +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); +/* indicates data finished, goto complete phase */ +return 1 ; + } + } + + ret =vfio_save_buffer (f, vbasedev, &data_size); +if (ret) { +error_report ("%s: vfio_save_buffer failed %s" , vbasedev->name, +strerror (errno)); +return ret; + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + +/* +* Reset pending_bytes as .save_live_pending is not called during savevm or +* snapshot case, in such case vfio_update_pending() at the start of this +* function updates pending_bytes. +*/ + migration->pending_bytes =0 ; +trace_vfio_save_iterate (vbasedev->name, data_size); +return 0 ; +} + +static int vfio_save_complete_precopy (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +uint64_t data_size; +int ret; + + ret =vfio_migration_set_state (vbasedev, ~VFIO_DEVICE_STATE_RUNNING , +VFIO_DEVICE_STATE_SAVING ); +if (ret) { +error_report ("%s: Failed to set state STOP and SAVING" , + vbasedev->name); +return ret; + } + + ret =vfio_save_device_config_state (f, opaque); +if (ret) { +return ret; + } + + ret =vfio_update_pending (vbasedev); +if (ret) { +return ret; + } + +while (migration->pending_bytes >0 ) { +qemu_put_be64 (f,VFIO_MIG_FLAG_DEV_DATA_STATE ); + ret =vfio_save_buffer (f, vbasedev, &data_size); +if (ret <0 ) { +error_report ("%s: Failed to save buffer" , vbasedev->name); +return ret; + } + +if (data_size ==0 ) { +break ; + } + + ret =vfio_update_pending (vbasedev); +if (ret) { +return ret; + } + } + +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); + + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + + ret =vfio_migration_set_state (vbasedev, ~VFIO_DEVICE_STATE_SAVING ,0 ); +if (ret) { +error_report ("%s: Failed to set state STOPPED" , vbasedev->name); +return ret; + } + +trace_vfio_save_complete_precopy (vbasedev->name); +return ret; +} +static SaveVMHandlers savevm_vfio_handlers = { .save_setup = vfio_save_setup, .save_cleanup = vfio_save_cleanup, + .save_live_pending = vfio_save_pending, + .save_live_iterate = vfio_save_iterate, + .save_live_complete_precopy = vfio_save_complete_precopy, };/* ---------------------------------------------------------------------- */
hw/vfio/trace-events +6 -0
@@ -153,3 +153,9 @@ vfio_vmstate_change(const char *name, int running, const char *reason, uint32_t vfio_migration_state_notifier(const char *name, const char *state) " (%s) state %s" vfio_save_setup(const char *name) " (%s)" vfio_save_cleanup(const char *name) " (%s)" +vfio_save_buffer(const char *name, uint64_t data_offset, uint64_t data_size, uint64_t pending) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64" pending 0x%"PRIx64 +vfio_update_pending(const char *name, uint64_t pending) " (%s) pending 0x%"PRIx64 +vfio_save_device_config_state(const char *name) " (%s)" +vfio_save_pending(const char *name, uint64_t precopy, uint64_t postcopy, uint64_t compatible) " (%s) precopy 0x%"PRIx64" postcopy 0x%"PRIx64" compatible 0x%"PRIx64 +vfio_save_iterate(const char *name, int data_size) " (%s) data_size %d" +vfio_save_complete_precopy(const char *name) " (%s)"
include/hw/vfio/vfio-common.h +1 -0
@@ -65,6 +65,7 @@ typedef struct VFIOMigration {uint32_t device_state;int vm_running;Notifier migration_state; +uint64_t pending_bytes; } VFIOMigration; typedef struct VFIOAddressSpace {
Signature · 1 line
2.7.0
PATCH v27 9/17 vfio: Add load state functions to SaveVMHandlers
In reply to Kirti WankhedeSequence during _RESUMING device state:
While data for this device is available, repeat below steps:
a. read data_offset from where user application should write data. b. write data of data_size to migration region from data_offset. c. write data_size which indicates vendor driver that data is written in
staging buffer.
For user, data is opaque. User should write data in the same order as received.
--- hw/vfio/migration.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + 2 files changed, 195 insertions(+)
hw/vfio/migration.c +192 -0
@@ -257,6 +257,77 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size)return ret; } +static int vfio_load_buffer (QEMUFile *f,VFIODevice *vbasedev, +uint64_t data_size) +{ +VFIORegion *region = &vbasedev->migration->region; +uint64_t data_offset =0 , size, report_size; +int ret; + +do { + ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +if (ret <0 ) { +return ret; + } + +if (data_offset + data_size > region->size) { +/* +* If data_size is greater than the data section of migration region +* then iterate the write buffer operation. This case can occur if +* size of migration region at destination is smaller than size of +* migration region at source. +*/ + report_size = size = region->size - data_offset; + data_size -= size; + }else { + report_size = size = data_size; + data_size =0 ; + } + +trace_vfio_load_state_device_data (vbasedev->name, data_offset, size); + +while (size) { +void *buf; +uint64_t sec_size; +bool buf_alloc = false; + + buf =get_data_section_size (region, data_offset, size, &sec_size); + +if (!buf) { + buf =g_try_malloc (sec_size); +if (!buf) { +error_report ("%s: Error allocating buffer " , __func__); +return -ENOMEM ; + } + buf_alloc = true; + } + +qemu_get_buffer (f, buf, sec_size); + +if (buf_alloc) { + ret =vfio_mig_write (vbasedev, buf, sec_size, + region->fd_offset + data_offset); +g_free (buf); + +if (ret <0 ) { +return ret; + } + } + size -= sec_size; + data_offset += sec_size; + } + + ret =vfio_mig_write (vbasedev, &report_size,sizeof (report_size), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +if (ret <0 ) { +return ret; + } + }while (data_size); + +return 0 ; +} +static int vfio_update_pending (VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration;
@@ -293,6 +364,33 @@ static int vfio_save_device_config_state(QEMUFile *f, void *opaque)return qemu_file_get_error (f); } +static int vfio_load_device_config_state (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +uint64_t data; + +if (vbasedev->ops && vbasedev->ops->vfio_load_config) { +int ret; + + ret = vbasedev->ops->vfio_load_config (vbasedev, f); +if (ret) { +error_report ("%s: Failed to load device config space" , + vbasedev->name); +return ret; + } + } + + data =qemu_get_be64 (f); +if (data !=VFIO_MIG_FLAG_END_OF_STATE ) { +error_report ("%s: Failed loading device config space, " +"end flag incorrect 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + +trace_vfio_load_device_config_state (vbasedev->name); +return qemu_file_get_error (f); +} +/* ---------------------------------------------------------------------- */ static int vfio_save_setup (QEMUFile *f,void *opaque)
@@ -477,12 +575,106 @@ static int vfio_save_complete_precopy(QEMUFile *f, void *opaque)return ret; } +static int vfio_load_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret =0 ; + +if (migration->region.mmaps) { + ret =vfio_region_mmap (&migration->region); +if (ret) { +error_report ("%s: Failed to mmap VFIO migration region %d: %s" , + vbasedev->name, migration->region.nr, +strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev, ~VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_RESUMING ); +if (ret) { +error_report ("%s: Failed to set state RESUMING" , vbasedev->name); +if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + } + } +return ret; +} + +static int vfio_load_cleanup (void *opaque) +{ +vfio_save_cleanup (opaque); +return 0 ; +} + +static int vfio_load_state (QEMUFile *f,void *opaque,int version_id) +{ +VFIODevice *vbasedev = opaque; +int ret =0 ; +uint64_t data; + + data =qemu_get_be64 (f); +while (data !=VFIO_MIG_FLAG_END_OF_STATE ) { + +trace_vfio_load_state (vbasedev->name, data); + +switch (data) { +case VFIO_MIG_FLAG_DEV_CONFIG_STATE : + { + ret =vfio_load_device_config_state (f, opaque); +if (ret) { +return ret; + } +break ; + } +case VFIO_MIG_FLAG_DEV_SETUP_STATE : + { + data =qemu_get_be64 (f); +if (data ==VFIO_MIG_FLAG_END_OF_STATE ) { +return ret; + }else { +error_report ("%s: SETUP STATE: EOS not found 0x%" PRIx64, + vbasedev->name, data); +return -EINVAL ; + } +break ; + } +case VFIO_MIG_FLAG_DEV_DATA_STATE : + { +uint64_t data_size =qemu_get_be64 (f); + +if (data_size) { + ret =vfio_load_buffer (f, vbasedev, data_size); +if (ret <0 ) { +return ret; + } + } +break ; + } +default : +error_report ("%s: Unknown tag 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + + data =qemu_get_be64 (f); + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + } +return ret; +} +static SaveVMHandlers savevm_vfio_handlers = { .save_setup = vfio_save_setup, .save_cleanup = vfio_save_cleanup, .save_live_pending = vfio_save_pending, .save_live_iterate = vfio_save_iterate, .save_live_complete_precopy = vfio_save_complete_precopy, + .load_setup = vfio_load_setup, + .load_cleanup = vfio_load_cleanup, + .load_state = vfio_load_state, };/* ---------------------------------------------------------------------- */
hw/vfio/trace-events +3 -0
@@ -159,3 +159,6 @@ vfio_save_device_config_state(const char *name) " (%s)" vfio_save_pending(const char *name, uint64_t precopy, uint64_t postcopy, uint64_t compatible) " (%s) precopy 0x%"PRIx64" postcopy 0x%"PRIx64" compatible 0x%"PRIx64 vfio_save_iterate(const char *name, int data_size) " (%s) data_size %d" vfio_save_complete_precopy(const char *name) " (%s)" +vfio_load_device_config_state(const char *name) " (%s)" +vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 +vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64
Signature · 1 line
2.7.0
Re: [PATCH v27 09/17] vfio: Add load state functions to SaveVMHandlers
Quoted 136 lines · On Thu, 22 Oct 2020 16:41:59 +0530 Kirti Wankhede <[email protected]> wrote:
Sequence during
_RESUMINGdevice state:
While data for this device is available, repeat below steps:
a. readdata_offsetfrom where user application should write data. b. write data ofdata_sizeto migration region fromdata_offset. c. writedata_sizewhich indicates vendor driver that data is written in
staging buffer.For user, data is opaque. User should write data in the same order as received.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/migration.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + 2 files changed, 195 insertions(+)hw/vfio/migration.c +98
-0@@ -257,6 +257,77 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size)return ret; } +static int vfio_load_buffer (QEMUFile *f,VFIODevice *vbasedev, +uint64_t data_size) +{ +VFIORegion *region = &vbasedev->migration->region; +uint64_t data_offset =0 , size, report_size; +int ret; + +do { + ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +if (ret <0 ) { +return ret; + } + +if (data_offset + data_size > region->size) { +/* +* If data_size is greater than the data section of migration region +* then iterate the write buffer operation. This case can occur if +* size of migration region at destination is smaller than size of +* migration region at source. +*/ + report_size = size = region->size - data_offset; + data_size -= size; + }else { + report_size = size = data_size; + data_size =0 ; + } + +trace_vfio_load_state_device_data (vbasedev->name, data_offset, size); + +while (size) { +void *buf; +uint64_t sec_size; +bool buf_alloc = false; + + buf =get_data_section_size (region, data_offset, size, &sec_size); + +if (!buf) { + buf =g_try_malloc (sec_size); +if (!buf) { +error_report ("%s: Error allocating buffer " , __func__); +return -ENOMEM ; + } + buf_alloc = true; + } + +qemu_get_buffer (f, buf, sec_size); + +if (buf_alloc) { + ret =vfio_mig_write (vbasedev, buf, sec_size, + region->fd_offset + data_offset); +g_free (buf); + +if (ret <0 ) { +return ret; + } + } + size -= sec_size; + data_offset += sec_size; + } + + ret =vfio_mig_write (vbasedev, &report_size,sizeof (report_size), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +if (ret <0 ) { +return ret; + } + }while (data_size); + +return 0 ; +} +static int vfio_update_pending (VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration;@@ -293,6 +364,33 @@ static int vfio_save_device_config_state(QEMUFile *f, void *opaque)return qemu_file_get_error (f); } +static int vfio_load_device_config_state (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +uint64_t data; + +if (vbasedev->ops && vbasedev->ops->vfio_load_config) { +int ret; + + ret = vbasedev->ops->vfio_load_config (vbasedev, f); +if (ret) { +error_report ("%s: Failed to load device config space" , + vbasedev->name); +return ret; + } + } + + data =qemu_get_be64 (f); +if (data !=VFIO_MIG_FLAG_END_OF_STATE ) { +error_report ("%s: Failed loading device config space, " +"end flag incorrect 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + +trace_vfio_load_device_config_state (vbasedev->name); +return qemu_file_get_error (f); +} +/* ---------------------------------------------------------------------- */ static int vfio_save_setup (QEMUFile *f,void *opaque)@@ -477,12 +575,106 @@ static int vfio_save_complete_precopy(QEMUFile *f, void *opaque)return ret;
hw/vfio/migration.c static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) · line 585
Quoted 10 lines
hw/vfio/migration.c +8
-0} +static int vfio_load_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret =0 ; + +if (migration->region.mmaps) { + ret =vfio_region_mmap (&migration->region);
Checking, are we in the right thread context not to require locking the iothread as we did in vfio_save_setup()?
Quoted 12 lines
hw/vfio/migration.c +12
-0+if (ret) { +error_report ("%s: Failed to mmap VFIO migration region %d: %s" , + vbasedev->name, migration->region.nr, +strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev, ~VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_RESUMING ); +if (ret) { +error_report ("%s: Failed to set state RESUMING" , vbasedev->name);
hw/vfio/migration.c static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) · line 607
Quoted 10 lines
hw/vfio/migration.c +10
-0+if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + } + } +return ret; +} + +static int vfio_load_cleanup (void *opaque) +{ +vfio_save_cleanup (opaque);
The tracing in there is going to be rather confusing. Thanks,
Alex
Quoted 84 lines
hw/vfio/migration.c +64
-0+return 0 ; +} + +static int vfio_load_state (QEMUFile *f,void *opaque,int version_id) +{ +VFIODevice *vbasedev = opaque; +int ret =0 ; +uint64_t data; + + data =qemu_get_be64 (f); +while (data !=VFIO_MIG_FLAG_END_OF_STATE ) { + +trace_vfio_load_state (vbasedev->name, data); + +switch (data) { +case VFIO_MIG_FLAG_DEV_CONFIG_STATE : + { + ret =vfio_load_device_config_state (f, opaque); +if (ret) { +return ret; + } +break ; + } +case VFIO_MIG_FLAG_DEV_SETUP_STATE : + { + data =qemu_get_be64 (f); +if (data ==VFIO_MIG_FLAG_END_OF_STATE ) { +return ret; + }else { +error_report ("%s: SETUP STATE: EOS not found 0x%" PRIx64, + vbasedev->name, data); +return -EINVAL ; + } +break ; + } +case VFIO_MIG_FLAG_DEV_DATA_STATE : + { +uint64_t data_size =qemu_get_be64 (f); + +if (data_size) { + ret =vfio_load_buffer (f, vbasedev, data_size); +if (ret <0 ) { +return ret; + } + } +break ; + } +default : +error_report ("%s: Unknown tag 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + + data =qemu_get_be64 (f); + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + } +return ret; +} +static SaveVMHandlers savevm_vfio_handlers = { .save_setup = vfio_save_setup, .save_cleanup = vfio_save_cleanup, .save_live_pending = vfio_save_pending, .save_live_iterate = vfio_save_iterate, .save_live_complete_precopy = vfio_save_complete_precopy, + .load_setup = vfio_load_setup, + .load_cleanup = vfio_load_cleanup, + .load_state = vfio_load_state, };/* ---------------------------------------------------------------------- */ hw/vfio/trace-events +3
-0@@ -159,3 +159,6 @@ vfio_save_device_config_state(const char *name) " (%s)" vfio_save_pending(const char *name, uint64_t precopy, uint64_t postcopy, uint64_t compatible) " (%s) precopy 0x%"PRIx64" postcopy 0x%"PRIx64" compatible 0x%"PRIx64 vfio_save_iterate(const char *name, int data_size) " (%s) data_size %d" vfio_save_complete_precopy(const char *name) " (%s)" +vfio_load_device_config_state(const char *name) " (%s)" +vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 +vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64
Re: [PATCH v27 09/17] vfio: Add load state functions to SaveVMHandlers
Quoted 141 lines · Alex Williamson
Quoted 138 lines · On Thu, 22 Oct 2020 16:41:59 +0530 Kirti Wankhede <[email protected]> wrote:
Sequence during
_RESUMINGdevice state:
While data for this device is available, repeat below steps:
a. readdata_offsetfrom where user application should write data. b. write data ofdata_sizeto migration region fromdata_offset. c. writedata_sizewhich indicates vendor driver that data is written in
staging buffer.For user, data is opaque. User should write data in the same order as received.
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Neo Jia <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/migration.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 3 + 2 files changed, 195 insertions(+)hw/vfio/migration.c +98
-0@@ -257,6 +257,77 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size)return ret; } +static int vfio_load_buffer (QEMUFile *f,VFIODevice *vbasedev, +uint64_t data_size) +{ +VFIORegion *region = &vbasedev->migration->region; +uint64_t data_offset =0 , size, report_size; +int ret; + +do { + ret =vfio_mig_read (vbasedev, &data_offset,sizeof (data_offset), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_offset)); +if (ret <0 ) { +return ret; + } + +if (data_offset + data_size > region->size) { +/* +* If data_size is greater than the data section of migration region +* then iterate the write buffer operation. This case can occur if +* size of migration region at destination is smaller than size of +* migration region at source. +*/ + report_size = size = region->size - data_offset; + data_size -= size; + }else { + report_size = size = data_size; + data_size =0 ; + } + +trace_vfio_load_state_device_data (vbasedev->name, data_offset, size); + +while (size) { +void *buf; +uint64_t sec_size; +bool buf_alloc = false; + + buf =get_data_section_size (region, data_offset, size, &sec_size); + +if (!buf) { + buf =g_try_malloc (sec_size); +if (!buf) { +error_report ("%s: Error allocating buffer " , __func__); +return -ENOMEM ; + } + buf_alloc = true; + } + +qemu_get_buffer (f, buf, sec_size); + +if (buf_alloc) { + ret =vfio_mig_write (vbasedev, buf, sec_size, + region->fd_offset + data_offset); +g_free (buf); + +if (ret <0 ) { +return ret; + } + } + size -= sec_size; + data_offset += sec_size; + } + + ret =vfio_mig_write (vbasedev, &report_size,sizeof (report_size), + region->fd_offset +VFIO_MIG_STRUCT_OFFSET (data_size)); +if (ret <0 ) { +return ret; + } + }while (data_size); + +return 0 ; +} +static int vfio_update_pending (VFIODevice *vbasedev) {VFIOMigration *migration = vbasedev->migration;@@ -293,6 +364,33 @@ static int vfio_save_device_config_state(QEMUFile *f, void *opaque)return qemu_file_get_error (f); } +static int vfio_load_device_config_state (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +uint64_t data; + +if (vbasedev->ops && vbasedev->ops->vfio_load_config) { +int ret; + + ret = vbasedev->ops->vfio_load_config (vbasedev, f); +if (ret) { +error_report ("%s: Failed to load device config space" , + vbasedev->name); +return ret; + } + } + + data =qemu_get_be64 (f); +if (data !=VFIO_MIG_FLAG_END_OF_STATE ) { +error_report ("%s: Failed loading device config space, " +"end flag incorrect 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + +trace_vfio_load_device_config_state (vbasedev->name); +return qemu_file_get_error (f); +} +/* ---------------------------------------------------------------------- */ static int vfio_save_setup (QEMUFile *f,void *opaque)@@ -477,12 +575,106 @@ static int vfio_save_complete_precopy(QEMUFile *f, void *opaque)return ret; }
Quoted 14 lines
hw/vfio/migration.c static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) · line 585
Quoted 8 lines
hw/vfio/migration.c +8
-0+static int vfio_load_setup (QEMUFile *f,void *opaque) +{ +VFIODevice *vbasedev = opaque; +VFIOMigration *migration = vbasedev->migration; +int ret =0 ; + +if (migration->region.mmaps) { + ret =vfio_region_mmap (&migration->region);Checking, are we in the right thread context not to require locking the iothread as we did in
vfio_save_setup()?
iothread lock is held when calling load_setup.
Quoted 17 lines
Quoted 17 lines
hw/vfio/migration.c +17
-0+if (ret) { +error_report ("%s: Failed to mmap VFIO migration region %d: %s" , + vbasedev->name, migration->region.nr, +strerror (-ret)); +error_report ("%s: Falling back to slow path" , vbasedev->name); + } + } + + ret =vfio_migration_set_state (vbasedev, ~VFIO_DEVICE_STATE_MASK , +VFIO_DEVICE_STATE_RESUMING ); +if (ret) { +error_report ("%s: Failed to set state RESUMING" , vbasedev->name); +if (migration->region.mmaps) { +vfio_region_unmap (&migration->region); + } + } +return ret;
Quoted 9 lines
hw/vfio/migration.c static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) · line 607
Quoted 5 lines
hw/vfio/migration.c +5
-0+} + +static int vfio_load_cleanup (void *opaque) +{ +vfio_save_cleanup (opaque);The tracing in there is going to be rather confusing. Thanks,
Updating patch 7 and this to separate tracing.
Thanks,
Kirti
Quoted 88 lines
Alex
Quoted 84 lines
hw/vfio/migration.c +64
-0+return 0 ; +} + +static int vfio_load_state (QEMUFile *f,void *opaque,int version_id) +{ +VFIODevice *vbasedev = opaque; +int ret =0 ; +uint64_t data; + + data =qemu_get_be64 (f); +while (data !=VFIO_MIG_FLAG_END_OF_STATE ) { + +trace_vfio_load_state (vbasedev->name, data); + +switch (data) { +case VFIO_MIG_FLAG_DEV_CONFIG_STATE : + { + ret =vfio_load_device_config_state (f, opaque); +if (ret) { +return ret; + } +break ; + } +case VFIO_MIG_FLAG_DEV_SETUP_STATE : + { + data =qemu_get_be64 (f); +if (data ==VFIO_MIG_FLAG_END_OF_STATE ) { +return ret; + }else { +error_report ("%s: SETUP STATE: EOS not found 0x%" PRIx64, + vbasedev->name, data); +return -EINVAL ; + } +break ; + } +case VFIO_MIG_FLAG_DEV_DATA_STATE : + { +uint64_t data_size =qemu_get_be64 (f); + +if (data_size) { + ret =vfio_load_buffer (f, vbasedev, data_size); +if (ret <0 ) { +return ret; + } + } +break ; + } +default : +error_report ("%s: Unknown tag 0x%" PRIx64, vbasedev->name, data); +return -EINVAL ; + } + + data =qemu_get_be64 (f); + ret =qemu_file_get_error (f); +if (ret) { +return ret; + } + } +return ret; +} +static SaveVMHandlers savevm_vfio_handlers = { .save_setup = vfio_save_setup, .save_cleanup = vfio_save_cleanup, .save_live_pending = vfio_save_pending, .save_live_iterate = vfio_save_iterate, .save_live_complete_precopy = vfio_save_complete_precopy, + .load_setup = vfio_load_setup, + .load_cleanup = vfio_load_cleanup, + .load_state = vfio_load_state, };/* ---------------------------------------------------------------------- */ hw/vfio/trace-events +3
-0@@ -159,3 +159,6 @@ vfio_save_device_config_state(const char *name) " (%s)" vfio_save_pending(const char *name, uint64_t precopy, uint64_t postcopy, uint64_t compatible) " (%s) precopy 0x%"PRIx64" postcopy 0x%"PRIx64" compatible 0x%"PRIx64 vfio_save_iterate(const char *name, int data_size) " (%s) data_size %d" vfio_save_complete_precopy(const char *name) " (%s)" +vfio_load_device_config_state(const char *name) " (%s)" +vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 +vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64
PATCH v27 10/17 memory: Set DIRTY_MEMORY_MIGRATION when IOMMU is enabled
In reply to Kirti Wankhedemr->ram_block is NULL when mr->is_iommu is true, then fr.dirty_log_mask wasn't set correctly due to which memory listener's log_sync doesn't get called.
This patch returns log_mask with DIRTY_MEMORY_MIGRATION set when IOMMU is enabled.
--- softmmu/memory.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
softmmu/memory.c +1 -1
@@ -1792,7 +1792,7 @@ bool memory_region_is_ram_device(MemoryRegion *mr)uint8_t memory_region_get_dirty_log_mask (MemoryRegion *mr) {uint8_t mask = mr->dirty_log_mask; -if (global_dirty_log && mr->ram_block) { +if (global_dirty_log && (mr->ram_block ||memory_region_is_iommu (mr))) { mask |= (1 <<DIRTY_MEMORY_MIGRATION ); }return mask;
Signature · 1 line
2.7.0
Re: [PATCH v27 10/17] memory: Set DIRTY_MEMORY_MIGRATION when IOMMU is enabled
Paolo,
I think this would need your ack. Thanks,
Alex
Quoted 24 lines · On Thu, 22 Oct 2020 16:42:00 +0530 Kirti Wankhede <[email protected]> wrote:
mr->ram_blockis NULL whenmr->is_iommuis true, then fr.dirty_log_mask wasn't set correctly due to which memory listener'slog_syncdoesn't get called.
This patch returnslog_maskwithDIRTY_MEMORY_MIGRATIONset when IOMMU is enabled.Signed-off-by Kirti Wankhede <[email protected]>--- softmmu/memory.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)softmmu/memory.c +1
-1@@ -1792,7 +1792,7 @@ bool memory_region_is_ram_device(MemoryRegion *mr)uint8_t memory_region_get_dirty_log_mask (MemoryRegion *mr) {uint8_t mask = mr->dirty_log_mask; -if (global_dirty_log && mr->ram_block) { +if (global_dirty_log && (mr->ram_block ||memory_region_is_iommu (mr))) { mask |= (1 <<DIRTY_MEMORY_MIGRATION ); }return mask;
PATCH v27 11/17 vfio: Get migration capability flags for container
In reply to Kirti WankhedeAdded helper functions to get IOMMU info capability chain. Added function to get migration capability information from that capability chain for IOMMU container.
Similar change was proposed earlier:
https://lists.gnu.org/archive/html/qemu-devel/2018-05/msg03759.html
Disable migration for devices if IOMMU module doesn't support migration capability.
--- hw/vfio/common.c | 90 +++++++++++++++++++++++++++++++++++++++---- hw/vfio/migration.c | 7 +++- include/hw/vfio/vfio-common.h | 3 ++ 3 files changed, 91 insertions(+), 9 deletions(-)
hw/vfio/common.c +82 -8
@@ -1228,6 +1228,75 @@ static int vfio_init_container(VFIOContainer *container, int group_fd,return 0 ; } +static int vfio_get_iommu_info (VFIOContainer *container, +struct vfio_iommu_type1_info **info) +{ + +size_t argsz =sizeof (struct vfio_iommu_type1_info ); + + *info = g_new0(struct vfio_iommu_type1_info, 1); +again: + (*info)->argsz = argsz; + +if (ioctl (container->fd,VFIO_IOMMU_GET_INFO , *info)) { +g_free (*info); + *info =NULL ; +return -errno; + } + +if (((*info)->argsz > argsz)) { + argsz = (*info)->argsz; + *info =g_realloc (*info, argsz); + goto again; + } + +return 0 ; +} + +static struct vfio_info_cap_header * +vfio_get_iommu_info_cap (struct vfio_iommu_type1_info *info,uint16_t id) +{ +struct vfio_info_cap_header *hdr; +void *ptr = info; + +if (!(info->flags &VFIO_IOMMU_INFO_CAPS )) { +return NULL ; + } + +for (hdr = ptr + info->cap_offset; hdr != ptr; hdr = ptr + hdr->next) { +if (hdr->id == id) { +return hdr; + } + } + +return NULL ; +} + +static void vfio_get_iommu_info_migration (VFIOContainer *container, +struct vfio_iommu_type1_info *info) +{ +struct vfio_info_cap_header *hdr; +struct vfio_iommu_type1_info_cap_migration *cap_mig; + + hdr =vfio_get_iommu_info_cap (info,VFIO_IOMMU_TYPE1_INFO_CAP_MIGRATION ); +if (!hdr) { +return ; + } + + cap_mig = container_of(hdr, struct vfio_iommu_type1_info_cap_migration, + header); + +/* +* cpu_physical_memory_set_dirty_lebitmap() expects pages in bitmap of +* TARGET_PAGE_SIZE to mark those dirty. +*/ +if (cap_mig->pgsize_bitmap &TARGET_PAGE_SIZE ) { + container->dirty_pages_supported = true; + container->max_dirty_bitmap_size = cap_mig->max_dirty_bitmap_size; + container->dirty_pgsizes = cap_mig->pgsize_bitmap; + } +} +static int vfio_connect_container (VFIOGroup *group,AddressSpace *as,Error **errp) {
@@ -1297,6 +1366,7 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as, container->space = space; container->fd = fd; container->error =NULL ; + container->dirty_pages_supported = false;QLIST_INIT (&container->giommu_list);QLIST_INIT (&container->hostwin_list);
@@ -1309,7 +1379,7 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as,case VFIO_TYPE1v2_IOMMU:case VFIO_TYPE1_IOMMU : { -struct vfio_iommu_type1_info info; +struct vfio_iommu_type1_info *info;/* * FIXME: This assumes that a Type1 IOMMU can map any 64-bit
@@ -1318,15 +1388,19 @@ static int vfio_connect_container(VFIOGroup *group, AddressSpace *as,* existing Type1 IOMMUs generally support any IOVA we're * going to actually try in practice. */ - info.argsz =sizeof (info); - ret =ioctl (fd,VFIO_IOMMU_GET_INFO , &info); -/* Ignore errors */ -if (ret || !(info.flags &VFIO_IOMMU_INFO_PGSIZES )) { + ret =vfio_get_iommu_info (container, &info); + +if (ret || !(info->flags &VFIO_IOMMU_INFO_PGSIZES )) {/* Assume 4k IOVA page size */ - info.iova_pgsizes =4096 ; + info->iova_pgsizes =4096 ; } -vfio_host_win_add (container,0 , (hwaddr)-1 , info.iova_pgsizes); - container->pgsizes = info.iova_pgsizes; +vfio_host_win_add (container,0 , (hwaddr)-1 , info->iova_pgsizes); + container->pgsizes = info->iova_pgsizes; + +if (!ret) { +vfio_get_iommu_info_migration (container, info); + } +g_free (info);break ; }case VFIO_SPAPR_TCE_v2_IOMMU:
hw/vfio/migration.c +6 -1
@@ -828,9 +828,14 @@ err:int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) { +VFIOContainer *container = vbasedev->group->container;struct vfio_region_info *info =NULL ;Error *local_err =NULL ; -int ret; +int ret = -ENOTSUP ; + +if (!container->dirty_pages_supported) { + goto add_blocker; + } ret =vfio_get_dev_region_info (vbasedev,VFIO_REGION_TYPE_MIGRATION ,VFIO_REGION_SUBTYPE_MIGRATION , &info);
include/hw/vfio/vfio-common.h +3 -0
@@ -84,6 +84,9 @@ typedef struct VFIOContainer {unsigned iommu_type;Error *error;bool initialized; +bool dirty_pages_supported; +uint64_t dirty_pgsizes; +uint64_t max_dirty_bitmap_size;unsigned long pgsizes; QLIST_HEAD(, VFIOGuestIOMMU) giommu_list; QLIST_HEAD(, VFIOHostDMAWindow) hostwin_list;
Signature · 1 line
2.7.0
PATCH v27 12/17 vfio: Add function to start and stop dirty pages tracking
In reply to Kirti WankhedeCall VFIO_IOMMU_DIRTY_PAGES ioctl to start and stop dirty pages tracking for VFIO devices.
--- hw/vfio/migration.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+)
hw/vfio/migration.c +36 -0
@@ -11,6 +11,7 @@#include "qemu/main-loop.h" #include "qemu/cutils.h" #include <linux/vfio.h> +#include <sys/ioctl.h> #include "sysemu/runstate.h" #include "hw/vfio/vfio-common.h"
@@ -391,6 +392,34 @@ static int vfio_load_device_config_state(QEMUFile *f, void *opaque)return qemu_file_get_error (f); } +static int vfio_set_dirty_page_tracking (VFIODevice *vbasedev,bool start) +{ +int ret; +VFIOMigration *migration = vbasedev->migration; +VFIOContainer *container = vbasedev->group->container; +struct vfio_iommu_type1_dirty_bitmap dirty = { + .argsz =sizeof (dirty), + }; + +if (start) { +if (migration->device_state &VFIO_DEVICE_STATE_SAVING ) { + dirty.flags =VFIO_IOMMU_DIRTY_PAGES_FLAG_START ; + }else { +return -EINVAL ; + } + }else { + dirty.flags =VFIO_IOMMU_DIRTY_PAGES_FLAG_STOP ; + } + + ret =ioctl (container->fd,VFIO_IOMMU_DIRTY_PAGES , &dirty); +if (ret) { +error_report ("Failed to set dirty tracking flag 0x%x errno: %d" , + dirty.flags, errno); +return -errno; + } +return ret; +} +/* ---------------------------------------------------------------------- */ static int vfio_save_setup (QEMUFile *f,void *opaque)
@@ -426,6 +455,11 @@ static int vfio_save_setup(QEMUFile *f, void *opaque)return ret; } + ret =vfio_set_dirty_page_tracking (vbasedev, true); +if (ret) { +return ret; + } +qemu_put_be64 (f,VFIO_MIG_FLAG_END_OF_STATE ); ret =qemu_file_get_error (f);
@@ -441,6 +475,8 @@ static void vfio_save_cleanup(void *opaque)VFIODevice *vbasedev = opaque;VFIOMigration *migration = vbasedev->migration; +vfio_set_dirty_page_tracking (vbasedev, false); +if (migration->region.mmaps) {vfio_region_unmap (&migration->region); }
Signature · 1 line
2.7.0
PATCH v27 13/17 vfio: Add vfio_listener_log_sync to mark dirty pages
In reply to Kirti Wankhedevfio_listener_log_sync gets list of dirty pages from container using VFIO_IOMMU_GET_DIRTY_BITMAP ioctl and mark those pages dirty when all devices are stopped and saving state.
Return early for the RAM block section of mapped MMIO region.
--- hw/vfio/common.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vfio/trace-events | 1 + 2 files changed, 117 insertions(+)
hw/vfio/common.c +116 -0
@@ -29,6 +29,7 @@#include "hw/vfio/vfio.h" #include "exec/address-spaces.h" #include "exec/memory.h" +#include "exec/ram_addr.h" #include "hw/hw.h" #include "qemu/error-report.h" #include "qemu/main-loop.h"
@@ -37,6 +38,7 @@#include "sysemu/reset.h" #include "trace.h" #include "qapi/error.h" +#include "migration/migration.h" VFIOGroupList vfio_group_list =QLIST_HEAD_INITIALIZER (vfio_group_list);
@@ -287,6 +289,39 @@ const MemoryRegionOps vfio_region_ops = { };/* +* Device state interfaces +*/ + +static bool vfio_devices_all_stopped_and_saving (VFIOContainer *container) +{ +VFIOGroup *group; +VFIODevice *vbasedev; +MigrationState *ms =migrate_get_current (); + +if (!migration_is_setup_or_active (ms->state)) { +return false; + } + + QLIST_FOREACH(group, &container->group_list, container_next) { + QLIST_FOREACH(vbasedev, &group->device_list, next) { +VFIOMigration *migration = vbasedev->migration; + +if (!migration) { +return false; + } + +if ((migration->device_state &VFIO_DEVICE_STATE_SAVING ) && + !(migration->device_state &VFIO_DEVICE_STATE_RUNNING )) { +continue ; + }else { +return false; + } + } + } +return true; +} + +/* * DMA - Mapping and unmapping for the "type1" IOMMU interface used on x86 */ static int vfio_dma_unmap(VFIOContainer *container,
@@ -812,9 +847,90 @@ static void vfio_listener_region_del(MemoryListener *listener, } } +static int vfio_get_dirty_bitmap (VFIOContainer *container,uint64_t iova, +uint64_t size,ram_addr_t ram_addr) +{ +struct vfio_iommu_type1_dirty_bitmap *dbitmap; +struct vfio_iommu_type1_dirty_bitmap_get *range; +uint64_t pages; +int ret; + + dbitmap =g_malloc0 (sizeof (*dbitmap) +sizeof (*range)); + + dbitmap->argsz =sizeof (*dbitmap) +sizeof (*range); + dbitmap->flags =VFIO_IOMMU_DIRTY_PAGES_FLAG_GET_BITMAP ; + range = (struct vfio_iommu_type1_dirty_bitmap_get *)&dbitmap->data; + range->iova = iova; + range->size = size; + +/* +* cpu_physical_memory_set_dirty_lebitmap() expects pages in bitmap of +* TARGET_PAGE_SIZE to mark those dirty. Hence set bitmap's pgsize to +* TARGET_PAGE_SIZE. +*/ + range->bitmap.pgsize =TARGET_PAGE_SIZE ; + + pages =TARGET_PAGE_ALIGN (range->size) >>TARGET_PAGE_BITS ; + range->bitmap.size =ROUND_UP (pages,sizeof (__u64) *BITS_PER_BYTE ) / +BITS_PER_BYTE ; + range->bitmap.data =g_try_malloc0 (range->bitmap.size); +if (!range->bitmap.data) { + ret = -ENOMEM ; + goto err_out; + } + + ret =ioctl (container->fd,VFIO_IOMMU_DIRTY_PAGES , dbitmap); +if (ret) { +error_report ("Failed to get dirty bitmap for iova: 0x%llx " +"size: 0x%llx err: %d" , + range->iova, range->size, errno); + goto err_out; + } + +cpu_physical_memory_set_dirty_lebitmap ((uint64_t *)range->bitmap.data, + ram_addr, pages); + +trace_vfio_get_dirty_bitmap (container->fd, range->iova, range->size, + range->bitmap.size, ram_addr); +err_out: +g_free (range->bitmap.data); +g_free (dbitmap); + +return ret; +} + +static int vfio_sync_dirty_bitmap (VFIOContainer *container, +MemoryRegionSection *section) +{ +ram_addr_t ram_addr; + + ram_addr =memory_region_get_ram_addr (section->mr) + + section->offset_within_region; + +return vfio_get_dirty_bitmap (container, +TARGET_PAGE_ALIGN (section->offset_within_address_space), +int128_get64 (section->size), ram_addr); +} + +static void vfio_listerner_log_sync (MemoryListener *listener, +MemoryRegionSection *section) +{ +VFIOContainer *container =container_of (listener, VFIOContainer, listener); + +if (vfio_listener_skipped_section (section) || + !container->dirty_pages_supported) { +return ; + } + +if (vfio_devices_all_stopped_and_saving (container)) { +vfio_sync_dirty_bitmap (container, section); + } +} +static const MemoryListener vfio_memory_listener = { .region_add = vfio_listener_region_add, .region_del = vfio_listener_region_del, + .log_sync = vfio_listerner_log_sync, };static void vfio_listener_release (VFIOContainer *container)
hw/vfio/trace-events +1 -0
@@ -162,3 +162,4 @@ vfio_save_complete_precopy(const char *name) " (%s)" vfio_load_device_config_state(const char *name) " (%s)" vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64 +vfio_get_dirty_bitmap(int fd, uint64_t iova, uint64_t size, uint64_t bitmap_size, uint64_t start) "container fd=%d, iova=0x%"PRIx64" size= 0x%"PRIx64" bitmap_size=0x%"PRIx64" start=0x%"PRIx64
Signature · 1 line
2.7.0
PATCH v27 14/17 vfio: Dirty page tracking when vIOMMU is enabled
In reply to Kirti WankhedeWhen vIOMMU is enabled, register MAP notifier from log_sync when all devices in container are in stop and copy phase of migration. Call replay and get dirty pages from notifier callback.
--- hw/vfio/common.c | 95 ++++++++++++++++++++++++++++++++++++++++--- hw/vfio/trace-events | 1 + include/hw/vfio/vfio-common.h | 1 + 3 files changed, 91 insertions(+), 6 deletions(-)
hw/vfio/common.c +89 -6
@@ -442,8 +442,8 @@ static bool vfio_listener_skipped_section(MemoryRegionSection *section) }/* Called with rcu_read_lock held. */ -static bool vfio_get_vaddr (IOMMUTLBEntry *iotlb,void **vaddr, -bool *read_only) +static bool vfio_get_xlat_addr (IOMMUTLBEntry *iotlb,void **vaddr, +ram_addr_t *ram_addr,bool *read_only) {MemoryRegion *mr;hwaddr xlat;
@@ -474,8 +474,17 @@ static bool vfio_get_vaddr(IOMMUTLBEntry *iotlb, void **vaddr,return false; } - *vaddr =memory_region_get_ram_ptr (mr) + xlat; - *read_only = !writable || mr->readonly; +if (vaddr) { + *vaddr =memory_region_get_ram_ptr (mr) + xlat; + } + +if (ram_addr) { + *ram_addr =memory_region_get_ram_addr (mr) + xlat; + } + +if (read_only) { + *read_only = !writable || mr->readonly; + }return true; }
@@ -485,7 +494,6 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, n);VFIOContainer *container = giommu->container;hwaddr iova = iotlb->iova + giommu->iommu_offset; -bool read_only;void *vaddr;int ret;
@@ -501,7 +509,9 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)rcu_read_lock ();if ((iotlb->perm &IOMMU_RW ) !=IOMMU_NONE ) { -if (!vfio_get_vaddr (iotlb, &vaddr, &read_only)) { +bool read_only; + +if (!vfio_get_xlat_addr (iotlb, &vaddr,NULL , &read_only)) { goto out; }/*
@@ -899,11 +909,84 @@ err_out:return ret; } +static void vfio_iommu_map_dirty_notify (IOMMUNotifier *n,IOMMUTLBEntry *iotlb) +{ +VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, dirty_notify); +VFIOContainer *container = giommu->container; +hwaddr iova = iotlb->iova + giommu->iommu_offset; +ram_addr_t translated_addr; + +trace_vfio_iommu_map_dirty_notify (iova, iova + iotlb->addr_mask); + +if (iotlb->target_as != &address_space_memory) { +error_report ("Wrong target AS \"%s\", only system memory is allowed" , + iotlb->target_as->name ? iotlb->target_as->name :"none" ); +return ; + } + +rcu_read_lock (); + +if (vfio_get_xlat_addr (iotlb,NULL , &translated_addr,NULL )) { +int ret; + + ret =vfio_get_dirty_bitmap (container, iova, iotlb->addr_mask +1 , + translated_addr); +if (ret) { +error_report ("vfio_iommu_map_dirty_notify(%p, 0x%" HWADDR_PRIx", " +"0x%" HWADDR_PRIx") = %d (%m)" , + container, iova, + iotlb->addr_mask +1 , ret); + } + } + +rcu_read_unlock (); +} +static int vfio_sync_dirty_bitmap (VFIOContainer *container,MemoryRegionSection *section) {ram_addr_t ram_addr; +if (memory_region_is_iommu (section->mr)) { +VFIOGuestIOMMU *giommu; +int ret =0 ; + + QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) { +if (MEMORY_REGION (giommu->iommu) == section->mr && + giommu->n.start == section->offset_within_region) { +Int128 llend; +Error *err =NULL ; +int idx =memory_region_iommu_attrs_to_index (giommu->iommu, +MEMTXATTRS_UNSPECIFIED ); + + llend =int128_add (int128_make64 (section->offset_within_region), + section->size); + llend =int128_sub (llend,int128_one ()); + +iommu_notifier_init (&giommu->dirty_notify, + vfio_iommu_map_dirty_notify, +IOMMU_NOTIFIER_MAP , + section->offset_within_region, +int128_get64 (llend), + idx); + ret =memory_region_register_iommu_notifier (section->mr, + &giommu->dirty_notify, &err); +if (ret) { +error_report_err (err); +break ; + } + +memory_region_iommu_replay (giommu->iommu, + &giommu->dirty_notify); + +memory_region_unregister_iommu_notifier (section->mr, + &giommu->dirty_notify); +break ; + } + } +return ret; + } + ram_addr =memory_region_get_ram_addr (section->mr) + section->offset_within_region;
hw/vfio/trace-events +1 -0
@@ -163,3 +163,4 @@ vfio_load_device_config_state(const char *name) " (%s)" vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64 vfio_get_dirty_bitmap(int fd, uint64_t iova, uint64_t size, uint64_t bitmap_size, uint64_t start) "container fd=%d, iova=0x%"PRIx64" size= 0x%"PRIx64" bitmap_size=0x%"PRIx64" start=0x%"PRIx64 +vfio_iommu_map_dirty_notify(uint64_t iova_start, uint64_t iova_end) "iommu dirty @ 0x%"PRIx64" - 0x%"PRIx64
include/hw/vfio/vfio-common.h +1 -0
@@ -99,6 +99,7 @@ typedef struct VFIOGuestIOMMU {IOMMUMemoryRegion *iommu;hwaddr iommu_offset;IOMMUNotifier n; +IOMMUNotifier dirty_notify;QLIST_ENTRY (VFIOGuestIOMMU) giommu_next; } VFIOGuestIOMMU;
Signature · 1 line
2.7.0
Re: [PATCH v27 14/17] vfio: Dirty page tracking when vIOMMU is enabled
Quoted 132 lines · On Thu, 22 Oct 2020 16:42:04 +0530 Kirti Wankhede <[email protected]> wrote:
When vIOMMU is enabled, register MAP notifier from
log_syncwhen all devices in container are in stop and copy phase of migration. Call replay and get dirty pages from notifier callback.Suggested-by Alex Williamson <[email protected]>Signed-off-by Kirti Wankhede <[email protected]>--- hw/vfio/common.c | 95 ++++++++++++++++++++++++++++++++++++++++--- hw/vfio/trace-events | 1 + include/hw/vfio/vfio-common.h | 1 + 3 files changed, 91 insertions(+), 6 deletions(-)hw/vfio/common.c +73
-6@@ -442,8 +442,8 @@ static bool vfio_listener_skipped_section(MemoryRegionSection *section) }/* Called with rcu_read_lock held. */ -static bool vfio_get_vaddr (IOMMUTLBEntry *iotlb,void **vaddr, -bool *read_only) +static bool vfio_get_xlat_addr (IOMMUTLBEntry *iotlb,void **vaddr, +ram_addr_t *ram_addr,bool *read_only) {MemoryRegion *mr;hwaddr xlat;@@ -474,8 +474,17 @@ static bool vfio_get_vaddr(IOMMUTLBEntry *iotlb, void **vaddr,return false; } - *vaddr =memory_region_get_ram_ptr (mr) + xlat; - *read_only = !writable || mr->readonly; +if (vaddr) { + *vaddr =memory_region_get_ram_ptr (mr) + xlat; + } + +if (ram_addr) { + *ram_addr =memory_region_get_ram_addr (mr) + xlat; + } + +if (read_only) { + *read_only = !writable || mr->readonly; + }return true; }@@ -485,7 +494,6 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, n);VFIOContainer *container = giommu->container;hwaddr iova = iotlb->iova + giommu->iommu_offset; -bool read_only;void *vaddr;int ret;@@ -501,7 +509,9 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)rcu_read_lock ();if ((iotlb->perm &IOMMU_RW ) !=IOMMU_NONE ) { -if (!vfio_get_vaddr (iotlb, &vaddr, &read_only)) { +bool read_only; + +if (!vfio_get_xlat_addr (iotlb, &vaddr,NULL , &read_only)) { goto out; }/* @@ -899,11 +909,84 @@ err_out:return ret; } +static void vfio_iommu_map_dirty_notify (IOMMUNotifier *n,IOMMUTLBEntry *iotlb) +{ +VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, dirty_notify); +VFIOContainer *container = giommu->container; +hwaddr iova = iotlb->iova + giommu->iommu_offset; +ram_addr_t translated_addr; + +trace_vfio_iommu_map_dirty_notify (iova, iova + iotlb->addr_mask); + +if (iotlb->target_as != &address_space_memory) { +error_report ("Wrong target AS \"%s\", only system memory is allowed" , + iotlb->target_as->name ? iotlb->target_as->name :"none" ); +return ; + } + +rcu_read_lock (); + +if (vfio_get_xlat_addr (iotlb,NULL , &translated_addr,NULL )) { +int ret; + + ret =vfio_get_dirty_bitmap (container, iova, iotlb->addr_mask +1 , + translated_addr); +if (ret) { +error_report ("vfio_iommu_map_dirty_notify(%p, 0x%" HWADDR_PRIx", " +"0x%" HWADDR_PRIx") = %d (%m)" , + container, iova, + iotlb->addr_mask +1 , ret); + } + } + +rcu_read_unlock (); +} +static int vfio_sync_dirty_bitmap (VFIOContainer *container,MemoryRegionSection *section) {ram_addr_t ram_addr; +if (memory_region_is_iommu (section->mr)) { +VFIOGuestIOMMU *giommu; +int ret =0 ; + + QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) { +if (MEMORY_REGION (giommu->iommu) == section->mr && + giommu->n.start == section->offset_within_region) { +Int128 llend; +Error *err =NULL ; +int idx =memory_region_iommu_attrs_to_index (giommu->iommu, +MEMTXATTRS_UNSPECIFIED ); + + llend =int128_add (int128_make64 (section->offset_within_region), + section->size); + llend =int128_sub (llend,int128_one ()); + +iommu_notifier_init (&giommu->dirty_notify, + vfio_iommu_map_dirty_notify, +IOMMU_NOTIFIER_MAP , + section->offset_within_region, +int128_get64 (llend), + idx); + ret =memory_region_register_iommu_notifier (section->mr, + &giommu->dirty_notify, &err);
hw/vfio/common.c err_out: · line 983
Quoted 10 lines
hw/vfio/common.c +10
-0+if (ret) { +error_report_err (err); +break ; + } + +memory_region_iommu_replay (giommu->iommu, + &giommu->dirty_notify); + +memory_region_unregister_iommu_notifier (section->mr, + &giommu->dirty_notify);
Is it necessary to do the register/unregister? It seemed to me that perhaps we could do a replay independent of those.
I'd also be tempted to move dirty_notify to a temporary object rather than store it on the giommu for such a brief usage, ie. define:
struct giommu_dirty_notfier {
IOMMUNotifier n;
VFIOGuestIOMMU *giommu;
}struct giommu_dirty_notfier n = { .giommu = giommu };
iommu_notifier_init(&n,...);
memory_region_iommu_replay(giommu->iommu, &n);
...
struct giommu_dirty_notfier *ndnotifier = container_of(n, struct giommu_dirty_notfier, n); VFIOGuestIOMMU *giommu = n->giommu;
It's nice that we remove the extra bloat of the list/tree entirely with this approach. Thanks,
Alex
Quoted 30 lines
hw/vfio/common.c +6
-0+break ; + } + } +return ret; + } + ram_addr =memory_region_get_ram_addr (section->mr) + section->offset_within_region;hw/vfio/trace-events +1
-0@@ -163,3 +163,4 @@ vfio_load_device_config_state(const char *name) " (%s)" vfio_load_state(const char *name, uint64_t data) " (%s) data 0x%"PRIx64 vfio_load_state_device_data(const char *name, uint64_t data_offset, uint64_t data_size) " (%s) Offset 0x%"PRIx64" size 0x%"PRIx64 vfio_get_dirty_bitmap(int fd, uint64_t iova, uint64_t size, uint64_t bitmap_size, uint64_t start) "container fd=%d, iova=0x%"PRIx64" size= 0x%"PRIx64" bitmap_size=0x%"PRIx64" start=0x%"PRIx64 +vfio_iommu_map_dirty_notify(uint64_t iova_start, uint64_t iova_end) "iommu dirty @ 0x%"PRIx64" - 0x%"PRIx64include/hw/vfio/vfio-common.h +1
-0@@ -99,6 +99,7 @@ typedef struct VFIOGuestIOMMU {IOMMUMemoryRegion *iommu;hwaddr iommu_offset;IOMMUNotifier n; +IOMMUNotifier dirty_notify;QLIST_ENTRY (VFIOGuestIOMMU) giommu_next; } VFIOGuestIOMMU;
Re: [PATCH v27 14/17] vfio: Dirty page tracking when vIOMMU is enabled
Quoted 141 lines · Alex Williamson
Quoted 138 lines · On Thu, 22 Oct 2020 16:42:04 +0530 Kirti Wankhede <[email protected]> wrote:
When vIOMMU is enabled, register MAP notifier from
log_syncwhen all devices in container are in stop and copy phase of migration. Call replay and get dirty pages from notifier callback.Suggested-by Alex Williamson <[email protected]>Signed-off-by Kirti Wankhede <[email protected]>--- hw/vfio/common.c | 95 ++++++++++++++++++++++++++++++++++++++++--- hw/vfio/trace-events | 1 + include/hw/vfio/vfio-common.h | 1 + 3 files changed, 91 insertions(+), 6 deletions(-)hw/vfio/common.c +79
-6@@ -442,8 +442,8 @@ static bool vfio_listener_skipped_section(MemoryRegionSection *section) }/* Called with rcu_read_lock held. */ -static bool vfio_get_vaddr (IOMMUTLBEntry *iotlb,void **vaddr, -bool *read_only) +static bool vfio_get_xlat_addr (IOMMUTLBEntry *iotlb,void **vaddr, +ram_addr_t *ram_addr,bool *read_only) {MemoryRegion *mr;hwaddr xlat;@@ -474,8 +474,17 @@ static bool vfio_get_vaddr(IOMMUTLBEntry *iotlb, void **vaddr,return false; } - *vaddr =memory_region_get_ram_ptr (mr) + xlat; - *read_only = !writable || mr->readonly; +if (vaddr) { + *vaddr =memory_region_get_ram_ptr (mr) + xlat; + } + +if (ram_addr) { + *ram_addr =memory_region_get_ram_addr (mr) + xlat; + } + +if (read_only) { + *read_only = !writable || mr->readonly; + }return true; }@@ -485,7 +494,6 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, n);VFIOContainer *container = giommu->container;hwaddr iova = iotlb->iova + giommu->iommu_offset; -bool read_only;void *vaddr;int ret;@@ -501,7 +509,9 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)rcu_read_lock ();if ((iotlb->perm &IOMMU_RW ) !=IOMMU_NONE ) { -if (!vfio_get_vaddr (iotlb, &vaddr, &read_only)) { +bool read_only; + +if (!vfio_get_xlat_addr (iotlb, &vaddr,NULL , &read_only)) { goto out; }/* @@ -899,11 +909,84 @@ err_out:return ret; } +static void vfio_iommu_map_dirty_notify (IOMMUNotifier *n,IOMMUTLBEntry *iotlb) +{ +VFIOGuestIOMMU *giommu =container_of (n, VFIOGuestIOMMU, dirty_notify); +VFIOContainer *container = giommu->container; +hwaddr iova = iotlb->iova + giommu->iommu_offset; +ram_addr_t translated_addr; + +trace_vfio_iommu_map_dirty_notify (iova, iova + iotlb->addr_mask); + +if (iotlb->target_as != &address_space_memory) { +error_report ("Wrong target AS \"%s\", only system memory is allowed" , + iotlb->target_as->name ? iotlb->target_as->name :"none" ); +return ; + } + +rcu_read_lock (); + +if (vfio_get_xlat_addr (iotlb,NULL , &translated_addr,NULL )) { +int ret; + + ret =vfio_get_dirty_bitmap (container, iova, iotlb->addr_mask +1 , + translated_addr); +if (ret) { +error_report ("vfio_iommu_map_dirty_notify(%p, 0x%" HWADDR_PRIx", " +"0x%" HWADDR_PRIx") = %d (%m)" , + container, iova, + iotlb->addr_mask +1 , ret); + } + } + +rcu_read_unlock (); +} +static int vfio_sync_dirty_bitmap (VFIOContainer *container,MemoryRegionSection *section) {ram_addr_t ram_addr; +if (memory_region_is_iommu (section->mr)) { +VFIOGuestIOMMU *giommu; +int ret =0 ; + + QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) { +if (MEMORY_REGION (giommu->iommu) == section->mr && + giommu->n.start == section->offset_within_region) { +Int128 llend; +Error *err =NULL ; +int idx =memory_region_iommu_attrs_to_index (giommu->iommu, +MEMTXATTRS_UNSPECIFIED ); + + llend =int128_add (int128_make64 (section->offset_within_region), + section->size); + llend =int128_sub (llend,int128_one ()); + +iommu_notifier_init (&giommu->dirty_notify, + vfio_iommu_map_dirty_notify, +IOMMU_NOTIFIER_MAP , + section->offset_within_region, +int128_get64 (llend), + idx); + ret =memory_region_register_iommu_notifier (section->mr, + &giommu->dirty_notify, &err); +if (ret) { +error_report_err (err); +break ; + } + + memory_region_iommu_replay(giommu->iommu,
Quoted 9 lines
hw/vfio/common.c err_out: · line 983
Quoted 4 lines
hw/vfio/common.c +4
-0+ &giommu->dirty_notify); + +memory_region_unregister_iommu_notifier (section->mr, + &giommu->dirty_notify);Is it necessary to do the register/unregister? It seemed to me that perhaps we could do a replay independent of those.
Earlier I thought to do a replay, we need to regsiter. But you are right, I verified replay works without registering.
Quoted 12 lines
I'd also be tempted to move
dirty_notifyto a temporary object rather than store it on the giommu for such a brief usage, ie. define:struct giommu_dirty_notfier { IOMMUNotifier n; VFIOGuestIOMMU *giommu; }struct
giommu_dirty_notfiern = { .giommu = giommu };
iommu_notifier_init(&n,...);
Quoted 9 lines
memory_region_iommu_replay(giommu->iommu, &n);
...struct
giommu_dirty_notfier*ndnotifier =container_of(n, struct giommu_dirty_notfier, n); VFIOGuestIOMMU *giommu =n->giommu;It's nice that we remove the extra bloat of the list/tree entirely with this approach. Thanks,
Thanks for your suggestion. Changing as you suggested above.
Thanks,
Kirti
PATCH v27 15/17 vfio: Add ioctl to get dirty pages bitmap during dma unmap
In reply to Kirti WankhedeWith vIOMMU, IO virtual address range can get unmapped while in pre-copy phase of migration. In that case, unmap ioctl should return pages pinned in that range and QEMU should find its correcponding guest physical addresses and report those dirty.
--- hw/vfio/common.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 92 insertions(+), 4 deletions(-)
hw/vfio/common.c +92 -4
@@ -321,11 +321,94 @@ static bool vfio_devices_all_stopped_and_saving(VFIOContainer *container)return true; } +static bool vfio_devices_all_running_and_saving (VFIOContainer *container) +{ +VFIOGroup *group; +VFIODevice *vbasedev; +MigrationState *ms =migrate_get_current (); + +if (!migration_is_setup_or_active (ms->state)) { +return false; + } + + QLIST_FOREACH(group, &container->group_list, container_next) { + QLIST_FOREACH(vbasedev, &group->device_list, next) { +VFIOMigration *migration = vbasedev->migration; + +if (!migration) { +return false; + } + +if ((migration->device_state &VFIO_DEVICE_STATE_SAVING ) && + (migration->device_state &VFIO_DEVICE_STATE_RUNNING )) { +continue ; + }else { +return false; + } + } + } +return true; +} + +static int vfio_dma_unmap_bitmap (VFIOContainer *container, +hwaddr iova,ram_addr_t size, +IOMMUTLBEntry *iotlb) +{ +struct vfio_iommu_type1_dma_unmap *unmap; +struct vfio_bitmap *bitmap; +uint64_t pages =TARGET_PAGE_ALIGN (size) >>TARGET_PAGE_BITS ; +int ret; + + unmap =g_malloc0 (sizeof (*unmap) +sizeof (*bitmap)); + + unmap->argsz =sizeof (*unmap) +sizeof (*bitmap); + unmap->iova = iova; + unmap->size = size; + unmap->flags |=VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP ; + bitmap = (struct vfio_bitmap *)&unmap->data; + +/* +* cpu_physical_memory_set_dirty_lebitmap() expects pages in bitmap of +* TARGET_PAGE_SIZE to mark those dirty. Hence set bitmap_pgsize to +* TARGET_PAGE_SIZE. +*/ + + bitmap->pgsize =TARGET_PAGE_SIZE ; + bitmap->size =ROUND_UP (pages,sizeof (__u64) *BITS_PER_BYTE ) / +BITS_PER_BYTE ; + +if (bitmap->size > container->max_dirty_bitmap_size) { +error_report ("UNMAP: Size of bitmap too big 0x%llx" , bitmap->size); + ret = -E2BIG ; + goto unmap_exit; + } + + bitmap->data =g_try_malloc0 (bitmap->size); +if (!bitmap->data) { + ret = -ENOMEM ; + goto unmap_exit; + } + + ret =ioctl (container->fd,VFIO_IOMMU_UNMAP_DMA , unmap); +if (!ret) { +cpu_physical_memory_set_dirty_lebitmap ((uint64_t *)bitmap->data, + iotlb->translated_addr, pages); + }else { +error_report ("VFIO_UNMAP_DMA with DIRTY_BITMAP : %m" ); + } + +g_free (bitmap->data); +unmap_exit: +g_free (unmap); +return ret; +} +/* * DMA - Mapping and unmapping for the "type1" IOMMU interface used on x86 */ static int vfio_dma_unmap (VFIOContainer *container, -hwaddr iova,ram_addr_t size) +hwaddr iova,ram_addr_t size, +IOMMUTLBEntry *iotlb) {struct vfio_iommu_type1_dma_unmap unmap = { .argsz =sizeof (unmap),
@@ -334,6 +417,11 @@ static int vfio_dma_unmap(VFIOContainer *container, .size = size, }; +if (iotlb && container->dirty_pages_supported && +vfio_devices_all_running_and_saving (container)) { +return vfio_dma_unmap_bitmap (container, iova, size, iotlb); + } +while (ioctl (container->fd,VFIO_IOMMU_UNMAP_DMA , &unmap)) {/* * The type1 backend has an off-by-one bug in the kernel (71a7d3d78e3c
@@ -381,7 +469,7 @@ static int vfio_dma_map(VFIOContainer *container, hwaddr iova,* the VGA ROM space. */ if (ioctl (container->fd,VFIO_IOMMU_MAP_DMA , &map) ==0 || - (errno ==EBUSY &&vfio_dma_unmap (container, iova, size) ==0 && + (errno ==EBUSY &&vfio_dma_unmap (container, iova, size,NULL ) ==0 &&ioctl (container->fd,VFIO_IOMMU_MAP_DMA , &map) ==0 )) {return 0 ; }
@@ -531,7 +619,7 @@ static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb) iotlb->addr_mask + 1, vaddr, ret); } }else { - ret =vfio_dma_unmap (container, iova, iotlb->addr_mask +1 ); + ret =vfio_dma_unmap (container, iova, iotlb->addr_mask +1 , iotlb);if (ret) { error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", " "0x%"HWADDR_PRIx") = %d (%m)",
@@ -834,7 +922,7 @@ static void vfio_listener_region_del(MemoryListener *listener, }if (try_unmap) { - ret =vfio_dma_unmap (container, iova,int128_get64 (llsize)); + ret =vfio_dma_unmap (container, iova,int128_get64 (llsize),NULL );if (ret) { error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", " "0x%"HWADDR_PRIx") = %d (%m)",
Signature · 1 line
2.7.0
PATCH v27 16/17 vfio: Make vfio-pci device migration capable
In reply to Kirti WankhedeIf the device is not a failover primary device, call vfio_migration_probe() and vfio_migration_finalize() to enable migration support for those devices that support it respectively to tear it down again.
Removed migration blocker from VFIO PCI device specific structure and use migration blocker from generic structure of VFIO device.
--- hw/vfio/pci.c | 28 ++++++++-------------------- hw/vfio/pci.h | 1 - 2 files changed, 8 insertions(+), 21 deletions(-)
hw/vfio/pci.c +8 -20
@@ -2788,17 +2788,6 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)return ; } -if (!pdev->failover_pair_id) { -error_setg (&vdev->migration_blocker, -"VFIO device doesn't support migration" ); - ret =migrate_add_blocker (vdev->migration_blocker, errp); -if (ret) { -error_free (vdev->migration_blocker); - vdev->migration_blocker =NULL ; -return ; - } - } - vdev->vbasedev.name =g_path_get_basename (vdev->vbasedev.sysfsdev); vdev->vbasedev.ops = &vfio_pci_ops; vdev->vbasedev.type =VFIO_DEVICE_TYPE_PCI ;
@@ -3066,6 +3055,13 @@ static void vfio_realize(PCIDevice *pdev, Error **errp) } } +if (!pdev->failover_pair_id) { + ret =vfio_migration_probe (&vdev->vbasedev, errp); +if (ret) { +error_report ("%s: Migration disabled" , vdev->vbasedev.name); + } + } +vfio_register_err_notifier (vdev);vfio_register_req_notifier (vdev);vfio_setup_resetfn_quirk (vdev);
@@ -3080,11 +3076,6 @@ out_teardown:vfio_bars_exit (vdev); error:error_prepend (errp,VFIO_MSG_PREFIX , vdev->vbasedev.name); -if (vdev->migration_blocker) { -migrate_del_blocker (vdev->migration_blocker); -error_free (vdev->migration_blocker); - vdev->migration_blocker =NULL ; - } }static void vfio_instance_finalize (Object *obj)
@@ -3096,10 +3087,6 @@ static void vfio_instance_finalize(Object *obj)vfio_bars_finalize (vdev);g_free (vdev->emulated_config_bits);g_free (vdev->rom); -if (vdev->migration_blocker) { -migrate_del_blocker (vdev->migration_blocker); -error_free (vdev->migration_blocker); - }/* * XXX Leaking igd_opregion is not an oversight, we can't remove the * fw_cfg entry therefore leaking this allocation seems like the safest
@@ -3127,6 +3114,7 @@ static void vfio_exitfn(PCIDevice *pdev) }vfio_teardown_msi (vdev);vfio_bars_exit (vdev); +vfio_migration_finalize (&vdev->vbasedev); }static void vfio_pci_reset (DeviceState *dev)
hw/vfio/pci.h +0 -1
@@ -172,7 +172,6 @@ struct VFIOPCIDevice {bool no_vfio_ioeventfd;bool enable_ramfb;VFIODisplay *dpy; -Error *migration_blocker;Notifier irqchip_change_notifier; };
Signature · 1 line
2.7.0
PATCH v27 17/17 qapi: Add VFIO devices migration stats in Migration stats
In reply to Kirti WankhedeAdded amount of bytes transferred to the VM at destination by all VFIO devices
--- hw/vfio/common.c | 20 ++++++++++++++++++++ hw/vfio/migration.c | 10 ++++++++++ include/qemu/vfio-helpers.h | 3 +++ migration/migration.c | 14 ++++++++++++++ monitor/hmp-cmds.c | 6 ++++++ qapi/migration.json | 17 +++++++++++++++++ 6 files changed, 70 insertions(+)
hw/vfio/common.c +20 -0
@@ -39,6 +39,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/migration.h" +#include "qemu/vfio-helpers.h" VFIOGroupList vfio_group_list =QLIST_HEAD_INITIALIZER (vfio_group_list);
@@ -292,6 +293,25 @@ const MemoryRegionOps vfio_region_ops = {* Device state interfaces */ +bool vfio_mig_active (void ) +{ +VFIOGroup *group; +VFIODevice *vbasedev; + +if (QLIST_EMPTY (&vfio_group_list)) { +return false; + } + + QLIST_FOREACH(group, &vfio_group_list, next) { + QLIST_FOREACH(vbasedev, &group->device_list, next) { +if (vbasedev->migration_blocker) { +return false; + } + } + } +return true; +} +static bool vfio_devices_all_stopped_and_saving (VFIOContainer *container) {VFIOGroup *group;
hw/vfio/migration.c +10 -0
@@ -28,6 +28,7 @@#include "pci.h" #include "trace.h" #include "hw/hw.h" +#include "qemu/vfio-helpers.h" /* * Flags to be used as unique delimiters for VFIO devices in the migration
@@ -45,6 +46,8 @@#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL)#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static int64_t bytes_transferred; +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {
@@ -255,6 +258,7 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size) *size = data_size; } + bytes_transferred += data_size;return ret; }
@@ -776,6 +780,7 @@ static void vfio_migration_state_notifier(Notifier *notifier, void *data)case MIGRATION_STATUS_CANCELLING :case MIGRATION_STATUS_CANCELLED :case MIGRATION_STATUS_FAILED : + bytes_transferred =0 ; ret =vfio_migration_set_state (vbasedev, ~(VFIO_DEVICE_STATE_SAVING |VFIO_DEVICE_STATE_RESUMING ),VFIO_DEVICE_STATE_RUNNING );
@@ -862,6 +867,11 @@ err:/* ---------------------------------------------------------------------- */ +int64_t vfio_mig_bytes_transferred (void ) +{ +return bytes_transferred; +} +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) {VFIOContainer *container = vbasedev->group->container;
include/qemu/vfio-helpers.h +3 -0
@@ -29,4 +29,7 @@ void qemu_vfio_pci_unmap_bar(QEMUVFIOState *s, int index, void *bar,int qemu_vfio_pci_init_irq (QEMUVFIOState *s,EventNotifier *e,int irq_type,Error **errp); +bool vfio_mig_active (void ); +int64_t vfio_mig_bytes_transferred (void ); +#endif
migration/migration.c +14 -0
@@ -56,6 +56,7 @@#include "net/announce.h" #include "qemu/queue.h" #include "multifd.h" +#include "qemu/vfio-helpers.h" #define MAX_THROTTLE (128 << 20)/* Migration transfer speed throttling */
@@ -1002,6 +1003,17 @@ static void populate_disk_info(MigrationInfo *info) } } +static void populate_vfio_info (MigrationInfo *info) +{ +#ifdef CONFIG_LINUX +if (vfio_mig_active ()) { + info->has_vfio = true; + info->vfio =g_malloc0 (sizeof (*info->vfio)); + info->vfio->transferred =vfio_mig_bytes_transferred (); + } +#endif +} +static void fill_source_migration_info (MigrationInfo *info) {MigrationState *s =migrate_get_current ();
@@ -1026,6 +1038,7 @@ static void fill_source_migration_info(MigrationInfo *info)populate_time_info (info, s);populate_ram_info (info, s);populate_disk_info (info); +populate_vfio_info (info);break ;case MIGRATION_STATUS_COLO : info->has_status = true;
@@ -1034,6 +1047,7 @@ static void fill_source_migration_info(MigrationInfo *info)case MIGRATION_STATUS_COMPLETED :populate_time_info (info, s);populate_ram_info (info, s); +populate_vfio_info (info);break ;case MIGRATION_STATUS_FAILED : info->has_status = true;
monitor/hmp-cmds.c +6 -0
@@ -357,6 +357,12 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) }monitor_printf (mon,"]\n" ); } + +if (info->has_vfio) { +monitor_printf (mon,"vfio device transferred: %" PRIu64" kbytes\n" , + info->vfio->transferred >>10 ); + } +qapi_free_MigrationInfo (info); }
qapi/migration.json +17 -0
@@ -147,6 +147,18 @@ 'active', 'postcopy-active', 'postcopy-paused', 'postcopy-recover', 'completed', 'failed', 'colo', 'pre-switchover', 'device', 'wait-unplug' ] } +## +# @VfioStats: +# +# Detailed VFIO devices migration statistics +# +# @transferred: amount of bytes transferred to the target VM by VFIO devices +# +# Since: 5.2 +# +## +{ 'struct': 'VfioStats', + 'data': {'transferred': 'int' } } ## # @MigrationInfo:
@@ -208,11 +220,16 @@ # # @socket-address: Only used for tcp, to know what the real port is (Since 4.0) # +# @vfio: @VfioStats containing detailed VFIO devices migration statistics, +# only returned if VFIO device is present, migration is supported by all +# VFIO devices and status is 'active' or 'completed' (since 5.2) +# # Since: 0.14.0 ## { 'struct': 'MigrationInfo', 'data': {'*status': 'MigrationStatus', '*ram': 'MigrationStats', '*disk': 'MigrationStats', + '*vfio': 'VfioStats', '*xbzrle-cache': 'XBZRLECacheStats', '*total-time': 'int', '*expected-downtime': 'int',
Signature · 1 line
2.7.0
Re: [PATCH v27 17/17] qapi: Add VFIO devices migration stats in Migration stats
Quoted 106 lines · On Thu, 22 Oct 2020 16:42:07 +0530 Kirti Wankhede <[email protected]> wrote:
Added amount of bytes transferred to the VM at destination by all VFIO devices
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/common.c | 20 ++++++++++++++++++++ hw/vfio/migration.c | 10 ++++++++++ include/qemu/vfio-helpers.h | 3 +++ migration/migration.c | 14 ++++++++++++++ monitor/hmp-cmds.c | 6 ++++++ qapi/migration.json | 17 +++++++++++++++++ 6 files changed, 70 insertions(+)hw/vfio/common.c +20
-0@@ -39,6 +39,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/migration.h" +#include "qemu/vfio-helpers.h" VFIOGroupList vfio_group_list =QLIST_HEAD_INITIALIZER (vfio_group_list);@@ -292,6 +293,25 @@ const MemoryRegionOps vfio_region_ops = {* Device state interfaces */ +bool vfio_mig_active (void ) +{ +VFIOGroup *group; +VFIODevice *vbasedev; + +if (QLIST_EMPTY (&vfio_group_list)) { +return false; + } + + QLIST_FOREACH(group, &vfio_group_list, next) { + QLIST_FOREACH(vbasedev, &group->device_list, next) { +if (vbasedev->migration_blocker) { +return false; + } + } + } +return true; +} +static bool vfio_devices_all_stopped_and_saving (VFIOContainer *container) {VFIOGroup *group;hw/vfio/migration.c +10
-0@@ -28,6 +28,7 @@#include "pci.h" #include "trace.h" #include "hw/hw.h" +#include "qemu/vfio-helpers.h" /* * Flags to be used as unique delimiters for VFIO devices in the migration @@ -45,6 +46,8 @@#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL)#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static int64_t bytes_transferred; +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {@@ -255,6 +258,7 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size) *size = data_size; } + bytes_transferred += data_size;return ret; }@@ -776,6 +780,7 @@ static void vfio_migration_state_notifier(Notifier *notifier, void *data)case MIGRATION_STATUS_CANCELLING :case MIGRATION_STATUS_CANCELLED :case MIGRATION_STATUS_FAILED : + bytes_transferred =0 ; ret =vfio_migration_set_state (vbasedev, ~(VFIO_DEVICE_STATE_SAVING |VFIO_DEVICE_STATE_RESUMING ),VFIO_DEVICE_STATE_RUNNING );@@ -862,6 +867,11 @@ err:/* ---------------------------------------------------------------------- */ +int64_t vfio_mig_bytes_transferred (void ) +{ +return bytes_transferred; +} +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) {VFIOContainer *container = vbasedev->group->container;include/qemu/vfio-helpers.h +0
-0
include/qemu/vfio-helpers.h void qemu_vfio_pci_unmap_bar(QEMUVFIOState *s, int index, void *bar, · line 35
Quoted 7 lines
include/qemu/vfio-helpers.h +3
-0@@ -29,4 +29,7 @@ void qemu_vfio_pci_unmap_bar(QEMUVFIOState *s, int index, void *bar,int qemu_vfio_pci_init_irq (QEMUVFIOState *s,EventNotifier *e,int irq_type,Error **errp); +bool vfio_mig_active (void ); +int64_t vfio_mig_bytes_transferred (void ); +#endif
I don't think vfio-helpers is the right place for this, this header is specifically for using util/vfio-helpers.c. Would include/hw/vfio/vfio-common.h work?
Quoted 13 lines
migration/migration.c +1
-0@@ -56,6 +56,7 @@#include "net/announce.h" #include "qemu/queue.h" #include "multifd.h" +#include "qemu/vfio-helpers.h" #define MAX_THROTTLE (128 << 20)/* Migration transfer speed throttling */
migration/migration.c static void populate_disk_info(MigrationInfo *info) · line 1008
Quoted 6 lines
migration/migration.c +3
-0@@ -1002,6 +1003,17 @@ static void populate_disk_info(MigrationInfo *info) } } +static void populate_vfio_info (MigrationInfo *info) +{ +#ifdef CONFIG_LINUX
Use CONFIG_VFIO? I get a build failure on qemu-system-avr
/usr/bin/ld: /tmp/tmp.3QbqxgbENl/build/../migration/migration.c:1012:
undefined reference to `vfio_mig_bytes_transferred'. Thanks,
Alex
Quoted 84 lines
migration/migration.c +10
-0+if (vfio_mig_active ()) { + info->has_vfio = true; + info->vfio =g_malloc0 (sizeof (*info->vfio)); + info->vfio->transferred =vfio_mig_bytes_transferred (); + } +#endif +} +static void fill_source_migration_info (MigrationInfo *info) {MigrationState *s =migrate_get_current ();@@ -1026,6 +1038,7 @@ static void fill_source_migration_info(MigrationInfo *info)populate_time_info (info, s);populate_ram_info (info, s);populate_disk_info (info); +populate_vfio_info (info);break ;case MIGRATION_STATUS_COLO : info->has_status = true;@@ -1034,6 +1047,7 @@ static void fill_source_migration_info(MigrationInfo *info)case MIGRATION_STATUS_COMPLETED :populate_time_info (info, s);populate_ram_info (info, s); +populate_vfio_info (info);break ;case MIGRATION_STATUS_FAILED : info->has_status = true;monitor/hmp-cmds.c +6
-0@@ -357,6 +357,12 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) }monitor_printf (mon,"]\n" ); } + +if (info->has_vfio) { +monitor_printf (mon,"vfio device transferred: %" PRIu64" kbytes\n" , + info->vfio->transferred >>10 ); + } +qapi_free_MigrationInfo (info); }qapi/migration.json +17
-0@@ -147,6 +147,18 @@ 'active', 'postcopy-active', 'postcopy-paused', 'postcopy-recover', 'completed', 'failed', 'colo', 'pre-switchover', 'device', 'wait-unplug' ] } +## +# @VfioStats: +# +# Detailed VFIO devices migration statistics +# +# @transferred: amount of bytes transferred to the target VM by VFIO devices +# +# Since: 5.2 +# +## +{ 'struct': 'VfioStats', + 'data': {'transferred': 'int' } } ## # @MigrationInfo:@@ -208,11 +220,16 @@ # # @socket-address: Only used for tcp, to know what the real port is (Since 4.0) # +# @vfio: @VfioStats containing detailed VFIO devices migration statistics, +# only returned if VFIO device is present, migration is supported by all +# VFIO devices and status is 'active' or 'completed' (since 5.2) +# # Since: 0.14.0 ## { 'struct': 'MigrationInfo', 'data': {'*status': 'MigrationStatus', '*ram': 'MigrationStats', '*disk': 'MigrationStats', + '*vfio': 'VfioStats', '*xbzrle-cache': 'XBZRLECacheStats', '*total-time': 'int', '*expected-downtime': 'int',
Re: [PATCH v27 17/17] qapi: Add VFIO devices migration stats in Migration stats
Quoted 112 lines · Alex Williamson
Quoted 109 lines · On Thu, 22 Oct 2020 16:42:07 +0530 Kirti Wankhede <[email protected]> wrote:
Added amount of bytes transferred to the VM at destination by all VFIO devices
Signed-off-by Kirti Wankhede <[email protected]>Reviewed-by Dr. David Alan Gilbert <[email protected]>--- hw/vfio/common.c | 20 ++++++++++++++++++++ hw/vfio/migration.c | 10 ++++++++++ include/qemu/vfio-helpers.h | 3 +++ migration/migration.c | 14 ++++++++++++++ monitor/hmp-cmds.c | 6 ++++++ qapi/migration.json | 17 +++++++++++++++++ 6 files changed, 70 insertions(+)hw/vfio/common.c +20
-0@@ -39,6 +39,7 @@#include "trace.h" #include "qapi/error.h" #include "migration/migration.h" +#include "qemu/vfio-helpers.h" VFIOGroupList vfio_group_list =QLIST_HEAD_INITIALIZER (vfio_group_list);@@ -292,6 +293,25 @@ const MemoryRegionOps vfio_region_ops = {* Device state interfaces */ +bool vfio_mig_active (void ) +{ +VFIOGroup *group; +VFIODevice *vbasedev; + +if (QLIST_EMPTY (&vfio_group_list)) { +return false; + } + + QLIST_FOREACH(group, &vfio_group_list, next) { + QLIST_FOREACH(vbasedev, &group->device_list, next) { +if (vbasedev->migration_blocker) { +return false; + } + } + } +return true; +} +static bool vfio_devices_all_stopped_and_saving (VFIOContainer *container) {VFIOGroup *group;hw/vfio/migration.c +10
-0@@ -28,6 +28,7 @@#include "pci.h" #include "trace.h" #include "hw/hw.h" +#include "qemu/vfio-helpers.h" /* * Flags to be used as unique delimiters for VFIO devices in the migration @@ -45,6 +46,8 @@#define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL)#define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) +static int64_t bytes_transferred; +static inline int vfio_mig_access (VFIODevice *vbasedev,void *val,int count,off_t off,bool iswrite) {@@ -255,6 +258,7 @@ static int vfio_save_buffer(QEMUFile *f, VFIODevice *vbasedev, uint64_t *size) *size = data_size; } + bytes_transferred += data_size;return ret; }@@ -776,6 +780,7 @@ static void vfio_migration_state_notifier(Notifier *notifier, void *data)case MIGRATION_STATUS_CANCELLING :case MIGRATION_STATUS_CANCELLED :case MIGRATION_STATUS_FAILED : + bytes_transferred =0 ; ret =vfio_migration_set_state (vbasedev, ~(VFIO_DEVICE_STATE_SAVING |VFIO_DEVICE_STATE_RESUMING ),VFIO_DEVICE_STATE_RUNNING );@@ -862,6 +867,11 @@ err:/* ---------------------------------------------------------------------- */ +int64_t vfio_mig_bytes_transferred (void ) +{ +return bytes_transferred; +} +int vfio_migration_probe (VFIODevice *vbasedev,Error **errp) {VFIOContainer *container = vbasedev->group->container;include/qemu/vfio-helpers.h +0
-0@@ -29,4 +29,7 @@ void qemu_vfio_pci_unmap_bar(QEMUVFIOState *s, int index, void *bar,int qemu_vfio_pci_init_irq (QEMUVFIOState *s,EventNotifier *e,int irq_type,Error **errp);
Quoted 11 lines
include/qemu/vfio-helpers.h void qemu_vfio_pci_unmap_bar(QEMUVFIOState *s, int index, void *bar, · line 35
Quoted 4 lines
include/qemu/vfio-helpers.h +3
-0+bool vfio_mig_active (void ); +int64_t vfio_mig_bytes_transferred (void ); +#endif I don't think vfio-helpers is the right place for this, this header is specifically for using
util/vfio-helpers.c. Wouldinclude/hw/vfio/vfio-common.hwork?
Yes, works with CONFIG_VFIO check. Changing it.
Quoted 16 lines
Quoted 16 lines
migration/migration.c +1
-0@@ -56,6 +56,7 @@#include "net/announce.h" #include "qemu/queue.h" #include "multifd.h" +#include "qemu/vfio-helpers.h" #define MAX_THROTTLE (128 << 20)/* Migration transfer speed throttling */ @@ -1002,6 +1003,17 @@ static void populate_disk_info(MigrationInfo *info) } }
Quoted 9 lines
migration/migration.c static void populate_disk_info(MigrationInfo *info) · line 1008
Quoted 3 lines
migration/migration.c +3
-0+static void populate_vfio_info (MigrationInfo *info) +{ +#ifdef CONFIG_LINUX Use
CONFIG_VFIO? I get a build failure on qemu-system-avr
/usr/bin/ld:/tmp/tmp.3QbqxgbENl/build/../migration/migration.c:1012:
undefined reference to `vfio_mig_bytes_transferred'. Thanks,
Ok Changing it.
Quoted 87 lines
Alex
Quoted 84 lines
migration/migration.c +10
-0+if (vfio_mig_active ()) { + info->has_vfio = true; + info->vfio =g_malloc0 (sizeof (*info->vfio)); + info->vfio->transferred =vfio_mig_bytes_transferred (); + } +#endif +} +static void fill_source_migration_info (MigrationInfo *info) {MigrationState *s =migrate_get_current ();@@ -1026,6 +1038,7 @@ static void fill_source_migration_info(MigrationInfo *info)populate_time_info (info, s);populate_ram_info (info, s);populate_disk_info (info); +populate_vfio_info (info);break ;case MIGRATION_STATUS_COLO : info->has_status = true;@@ -1034,6 +1047,7 @@ static void fill_source_migration_info(MigrationInfo *info)case MIGRATION_STATUS_COMPLETED :populate_time_info (info, s);populate_ram_info (info, s); +populate_vfio_info (info);break ;case MIGRATION_STATUS_FAILED : info->has_status = true;monitor/hmp-cmds.c +6
-0@@ -357,6 +357,12 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) }monitor_printf (mon,"]\n" ); } + +if (info->has_vfio) { +monitor_printf (mon,"vfio device transferred: %" PRIu64" kbytes\n" , + info->vfio->transferred >>10 ); + } +qapi_free_MigrationInfo (info); }qapi/migration.json +17
-0@@ -147,6 +147,18 @@ 'active', 'postcopy-active', 'postcopy-paused', 'postcopy-recover', 'completed', 'failed', 'colo', 'pre-switchover', 'device', 'wait-unplug' ] } +## +# @VfioStats: +# +# Detailed VFIO devices migration statistics +# +# @transferred: amount of bytes transferred to the target VM by VFIO devices +# +# Since: 5.2 +# +## +{ 'struct': 'VfioStats', + 'data': {'transferred': 'int' } } ## # @MigrationInfo:@@ -208,11 +220,16 @@ # # @socket-address: Only used for tcp, to know what the real port is (Since 4.0) # +# @vfio: @VfioStats containing detailed VFIO devices migration statistics, +# only returned if VFIO device is present, migration is supported by all +# VFIO devices and status is 'active' or 'completed' (since 5.2) +# # Since: 0.14.0 ## { 'struct': 'MigrationInfo', 'data': {'*status': 'MigrationStatus', '*ram': 'MigrationStats', '*disk': 'MigrationStats', + '*vfio': 'VfioStats', '*xbzrle-cache': 'XBZRLECacheStats', '*total-time': 'int', '*expected-downtime': 'int',
Quoted 3 lines · On Thu, 22 Oct 2020 16:41:50 +0530 Kirti Wankhede <[email protected]> wrote:
Hi,
This Patch set adds migration support for VFIO devices in QEMU.
We're cutting it pretty close for the 5.2 soft freeze, but clearly we've seen this series a few times. The key points for me are that I no longer see anything that should adversely affect non-migration support (aside from the easily fixed bugs noted) and I think our config space vmstate is sane now, so we hopefully won't need to throw it away and start over (experts, please verify). I think there's still a respin needed, but I hope that others can squeeze in a review, find and verify issues they've noted previously, re-confirm their reviews and acks, and maybe we can get this in by Tuesday. If migration is broken, we can fix that as we go, but the foundation looks reasonable enough to me. Thanks,
Alex