vfio_dev.c

  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
 11struct pci_dev *pds_vfio_to_pci_dev(struct pds_vfio_pci_device *pds_vfio)
 12{
 13	return pds_vfio->vfio_coredev.pdev;
 14}
 15
 16struct 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
 21struct 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
 29void pds_vfio_reset(struct pds_vfio_pci_device *pds_vfio,
 30		    enum vfio_device_mig_state state)
 31{
 32	pds_vfio_put_restore_file(pds_vfio);
 33	pds_vfio_put_save_file(pds_vfio);
 34	if (state == VFIO_DEVICE_STATE_ERROR)
 35		pds_vfio_dirty_disable(pds_vfio, false);
 36	pds_vfio->state = state;
 37}
 38
 39static struct file *
 40pds_vfio_set_device_state(struct vfio_device *vdev,
 41			  enum vfio_device_mig_state new_state)
 42{
 43	struct pds_vfio_pci_device *pds_vfio =
 44		container_of(vdev, struct pds_vfio_pci_device,
 45			     vfio_coredev.vdev);
 46	struct file *res = NULL;
 47
 48	mutex_lock(&pds_vfio->state_mutex);
 49	/*
 50	 * only way to transition out of VFIO_DEVICE_STATE_ERROR is via
 51	 * VFIO_DEVICE_RESET, so prevent the state machine from running since
 52	 * vfio_mig_get_next_state() will throw a WARN_ON() when transitioning
 53	 * from VFIO_DEVICE_STATE_ERROR to any other state
 54	 */
 55	while (pds_vfio->state != VFIO_DEVICE_STATE_ERROR &&
 56	       new_state != pds_vfio->state) {
 57		enum vfio_device_mig_state next_state;
 58
 59		int err = vfio_mig_get_next_state(vdev, pds_vfio->state,
 60						  new_state, &next_state);
 61		if (err) {
 62			res = ERR_PTR(err);
 63			break;
 64		}
 65
 66		res = pds_vfio_step_device_state_locked(pds_vfio, next_state);
 67		if (IS_ERR(res))
 68			break;
 69
 70		pds_vfio->state = next_state;
 71
 72		if (WARN_ON(res && new_state != pds_vfio->state)) {
 73			res = ERR_PTR(-EINVAL);
 74			break;
 75		}
 76	}
 77	mutex_unlock(&pds_vfio->state_mutex);
 78	if (pds_vfio->state == VFIO_DEVICE_STATE_ERROR)
 79		res = ERR_PTR(-EIO);
 80
 81	return res;
 82}
 83
 84static int pds_vfio_get_device_state(struct vfio_device *vdev,
 85				     enum vfio_device_mig_state *current_state)
 86{
 87	struct pds_vfio_pci_device *pds_vfio =
 88		container_of(vdev, struct pds_vfio_pci_device,
 89			     vfio_coredev.vdev);
 90
 91	mutex_lock(&pds_vfio->state_mutex);
 92	*current_state = pds_vfio->state;
 93	mutex_unlock(&pds_vfio->state_mutex);
 94	return 0;
 95}
 96
 97static int pds_vfio_get_device_state_size(struct vfio_device *vdev,
 98					  unsigned long *stop_copy_length)
 99{
100	*stop_copy_length = PDS_LM_DEVICE_STATE_LENGTH;
101	return 0;
102}
103
104static const struct vfio_migration_ops pds_vfio_lm_ops = {
105	.migration_set_state = pds_vfio_set_device_state,
106	.migration_get_state = pds_vfio_get_device_state,
107	.migration_get_data_size = pds_vfio_get_device_state_size
108};
109
110static const struct vfio_log_ops pds_vfio_log_ops = {
111	.log_start = pds_vfio_dma_logging_start,
112	.log_stop = pds_vfio_dma_logging_stop,
113	.log_read_and_clear = pds_vfio_dma_logging_report,
114};
115
116static int pds_vfio_init_device(struct vfio_device *vdev)
117{
118	struct pds_vfio_pci_device *pds_vfio =
119		container_of(vdev, struct pds_vfio_pci_device,
120			     vfio_coredev.vdev);
121	struct pci_dev *pdev = to_pci_dev(vdev->dev);
122	int err, vf_id, pci_id;
123
124	vf_id = pci_iov_vf_id(pdev);
125	if (vf_id < 0)
126		return vf_id;
127
128	err = vfio_pci_core_init_dev(vdev);
129	if (err)
130		return err;
131
132	pds_vfio->vf_id = vf_id;
133
134	mutex_init(&pds_vfio->state_mutex);
135
136	vdev->migration_flags = VFIO_MIGRATION_STOP_COPY | VFIO_MIGRATION_P2P;
137	vdev->mig_ops = &pds_vfio_lm_ops;
138	vdev->log_ops = &pds_vfio_log_ops;
139
140	pci_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
141	dev_dbg(&pdev->dev,
142		"%s: PF %#04x VF %#04x vf_id %d domain %d pds_vfio %p\n",
143		__func__, pci_dev_id(pci_physfn(pdev)), pci_id, vf_id,
144		pci_domain_nr(pdev->bus), pds_vfio);
145
146	return 0;
147}
148
149static void pds_vfio_release_device(struct vfio_device *vdev)
150{
151	struct pds_vfio_pci_device *pds_vfio =
152		container_of(vdev, struct pds_vfio_pci_device,
153			     vfio_coredev.vdev);
154
155	mutex_destroy(&pds_vfio->state_mutex);
156	vfio_pci_core_release_dev(vdev);
157}
158
159static 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	pds_vfio->state = VFIO_DEVICE_STATE_RUNNING;
171
172	vfio_pci_core_finish_enable(&pds_vfio->vfio_coredev);
173
174	return 0;
175}
176
177static void pds_vfio_close_device(struct vfio_device *vdev)
178{
179	struct pds_vfio_pci_device *pds_vfio =
180		container_of(vdev, struct pds_vfio_pci_device,
181			     vfio_coredev.vdev);
182
183	mutex_lock(&pds_vfio->state_mutex);
184	pds_vfio_put_restore_file(pds_vfio);
185	pds_vfio_put_save_file(pds_vfio);
186	pds_vfio_dirty_disable(pds_vfio, true);
187	mutex_unlock(&pds_vfio->state_mutex);
188	vfio_pci_core_close_device(vdev);
189}
190
191static const struct vfio_device_ops pds_vfio_ops = {
192	.name = "pds-vfio",
193	.init = pds_vfio_init_device,
194	.release = pds_vfio_release_device,
195	.open_device = pds_vfio_open_device,
196	.close_device = pds_vfio_close_device,
197	.ioctl = vfio_pci_core_ioctl,
198	.get_region_info_caps = vfio_pci_ioctl_get_region_info,
199	.device_feature = vfio_pci_core_ioctl_feature,
200	.read = vfio_pci_core_read,
201	.write = vfio_pci_core_write,
202	.mmap = vfio_pci_core_mmap,
203	.request = vfio_pci_core_request,
204	.match = vfio_pci_core_match,
205	.match_token_uuid = vfio_pci_core_match_token_uuid,
206	.bind_iommufd = vfio_iommufd_physical_bind,
207	.unbind_iommufd = vfio_iommufd_physical_unbind,
208	.attach_ioas = vfio_iommufd_physical_attach_ioas,
209	.detach_ioas = vfio_iommufd_physical_detach_ioas,
210};
211
212const struct vfio_device_ops *pds_vfio_ops_info(void)
213{
214	return &pds_vfio_ops;
215}