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