1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2023 Advanced Micro Devices, Inc. */ 3 4 #include <linux/vfio.h> 5 #include <linux/vfio_pci_core.h> 6 7 #include "lm.h" 8 #include "dirty.h" 9 #include "vfio_dev.h" 10 11 struct pci_dev *pds_vfio_to_pci_dev(struct pds_vfio_pci_device *pds_vfio) 12 { 13 return pds_vfio->vfio_coredev.pdev; 14 } 15 16 struct device *pds_vfio_to_dev(struct pds_vfio_pci_device *pds_vfio) 17 { 18 return &pds_vfio_to_pci_dev(pds_vfio)->dev; 19 } 20 21 struct pds_vfio_pci_device *pds_vfio_pci_drvdata(struct pci_dev *pdev) 22 { 23 struct vfio_pci_core_device *core_device = dev_get_drvdata(&pdev->dev); 24 25 return container_of(core_device, struct pds_vfio_pci_device, 26 vfio_coredev); 27 } 28 29 void pds_vfio_state_mutex_unlock(struct pds_vfio_pci_device *pds_vfio) 30 { 31 again: 32 spin_lock(&pds_vfio->reset_lock); 33 if (pds_vfio->deferred_reset) { 34 pds_vfio->deferred_reset = false; 35 if (pds_vfio->state == VFIO_DEVICE_STATE_ERROR) { 36 pds_vfio->state = VFIO_DEVICE_STATE_RUNNING; 37 pds_vfio_put_restore_file(pds_vfio); 38 pds_vfio_put_save_file(pds_vfio); 39 pds_vfio_dirty_disable(pds_vfio, false); 40 } 41 spin_unlock(&pds_vfio->reset_lock); 42 goto again; 43 } 44 mutex_unlock(&pds_vfio->state_mutex); 45 spin_unlock(&pds_vfio->reset_lock); 46 } 47 48 void pds_vfio_reset(struct pds_vfio_pci_device *pds_vfio) 49 { 50 spin_lock(&pds_vfio->reset_lock); 51 pds_vfio->deferred_reset = true; 52 if (!mutex_trylock(&pds_vfio->state_mutex)) { 53 spin_unlock(&pds_vfio->reset_lock); 54 return; 55 } 56 spin_unlock(&pds_vfio->reset_lock); 57 pds_vfio_state_mutex_unlock(pds_vfio); 58 } 59 60 static struct file * 61 pds_vfio_set_device_state(struct vfio_device *vdev, 62 enum vfio_device_mig_state new_state) 63 { 64 struct pds_vfio_pci_device *pds_vfio = 65 container_of(vdev, struct pds_vfio_pci_device, 66 vfio_coredev.vdev); 67 struct file *res = NULL; 68 69 mutex_lock(&pds_vfio->state_mutex); 70 while (new_state != pds_vfio->state) { 71 enum vfio_device_mig_state next_state; 72 73 int err = vfio_mig_get_next_state(vdev, pds_vfio->state, 74 new_state, &next_state); 75 if (err) { 76 res = ERR_PTR(err); 77 break; 78 } 79 80 res = pds_vfio_step_device_state_locked(pds_vfio, next_state); 81 if (IS_ERR(res)) 82 break; 83 84 pds_vfio->state = next_state; 85 86 if (WARN_ON(res && new_state != pds_vfio->state)) { 87 res = ERR_PTR(-EINVAL); 88 break; 89 } 90 } 91 pds_vfio_state_mutex_unlock(pds_vfio); 92 93 return res; 94 } 95 96 static int pds_vfio_get_device_state(struct vfio_device *vdev, 97 enum vfio_device_mig_state *current_state) 98 { 99 struct pds_vfio_pci_device *pds_vfio = 100 container_of(vdev, struct pds_vfio_pci_device, 101 vfio_coredev.vdev); 102 103 mutex_lock(&pds_vfio->state_mutex); 104 *current_state = pds_vfio->state; 105 pds_vfio_state_mutex_unlock(pds_vfio); 106 return 0; 107 } 108 109 static int pds_vfio_get_device_state_size(struct vfio_device *vdev, 110 unsigned long *stop_copy_length) 111 { 112 *stop_copy_length = PDS_LM_DEVICE_STATE_LENGTH; 113 return 0; 114 } 115 116 static const struct vfio_migration_ops pds_vfio_lm_ops = { 117 .migration_set_state = pds_vfio_set_device_state, 118 .migration_get_state = pds_vfio_get_device_state, 119 .migration_get_data_size = pds_vfio_get_device_state_size 120 }; 121 122 static const struct vfio_log_ops pds_vfio_log_ops = { 123 .log_start = pds_vfio_dma_logging_start, 124 .log_stop = pds_vfio_dma_logging_stop, 125 .log_read_and_clear = pds_vfio_dma_logging_report, 126 }; 127 128 static int pds_vfio_init_device(struct vfio_device *vdev) 129 { 130 struct pds_vfio_pci_device *pds_vfio = 131 container_of(vdev, struct pds_vfio_pci_device, 132 vfio_coredev.vdev); 133 struct pci_dev *pdev = to_pci_dev(vdev->dev); 134 int err, vf_id, pci_id; 135 136 vf_id = pci_iov_vf_id(pdev); 137 if (vf_id < 0) 138 return vf_id; 139 140 err = vfio_pci_core_init_dev(vdev); 141 if (err) 142 return err; 143 144 pds_vfio->vf_id = vf_id; 145 146 vdev->migration_flags = VFIO_MIGRATION_STOP_COPY | VFIO_MIGRATION_P2P; 147 vdev->mig_ops = &pds_vfio_lm_ops; 148 vdev->log_ops = &pds_vfio_log_ops; 149 150 pci_id = PCI_DEVID(pdev->bus->number, pdev->devfn); 151 dev_dbg(&pdev->dev, 152 "%s: PF %#04x VF %#04x vf_id %d domain %d pds_vfio %p\n", 153 __func__, pci_dev_id(pdev->physfn), pci_id, vf_id, 154 pci_domain_nr(pdev->bus), pds_vfio); 155 156 return 0; 157 } 158 159 static int pds_vfio_open_device(struct vfio_device *vdev) 160 { 161 struct pds_vfio_pci_device *pds_vfio = 162 container_of(vdev, struct pds_vfio_pci_device, 163 vfio_coredev.vdev); 164 int err; 165 166 err = vfio_pci_core_enable(&pds_vfio->vfio_coredev); 167 if (err) 168 return err; 169 170 mutex_init(&pds_vfio->state_mutex); 171 pds_vfio->state = VFIO_DEVICE_STATE_RUNNING; 172 173 vfio_pci_core_finish_enable(&pds_vfio->vfio_coredev); 174 175 return 0; 176 } 177 178 static void pds_vfio_close_device(struct vfio_device *vdev) 179 { 180 struct pds_vfio_pci_device *pds_vfio = 181 container_of(vdev, struct pds_vfio_pci_device, 182 vfio_coredev.vdev); 183 184 mutex_lock(&pds_vfio->state_mutex); 185 pds_vfio_put_restore_file(pds_vfio); 186 pds_vfio_put_save_file(pds_vfio); 187 pds_vfio_dirty_disable(pds_vfio, true); 188 mutex_unlock(&pds_vfio->state_mutex); 189 mutex_destroy(&pds_vfio->state_mutex); 190 vfio_pci_core_close_device(vdev); 191 } 192 193 static const struct vfio_device_ops pds_vfio_ops = { 194 .name = "pds-vfio", 195 .init = pds_vfio_init_device, 196 .release = vfio_pci_core_release_dev, 197 .open_device = pds_vfio_open_device, 198 .close_device = pds_vfio_close_device, 199 .ioctl = vfio_pci_core_ioctl, 200 .device_feature = vfio_pci_core_ioctl_feature, 201 .read = vfio_pci_core_read, 202 .write = vfio_pci_core_write, 203 .mmap = vfio_pci_core_mmap, 204 .request = vfio_pci_core_request, 205 .match = vfio_pci_core_match, 206 .bind_iommufd = vfio_iommufd_physical_bind, 207 .unbind_iommufd = vfio_iommufd_physical_unbind, 208 .attach_ioas = vfio_iommufd_physical_attach_ioas, 209 }; 210 211 const struct vfio_device_ops *pds_vfio_ops_info(void) 212 { 213 return &pds_vfio_ops; 214 } 215