xref: /openbmc/qemu/hw/vfio/ap.c (revision effd60c8)
1 /*
2  * VFIO based AP matrix device assignment
3  *
4  * Copyright 2018 IBM Corp.
5  * Author(s): Tony Krowiak <akrowiak@linux.ibm.com>
6  *            Halil Pasic <pasic@linux.ibm.com>
7  *
8  * This work is licensed under the terms of the GNU GPL, version 2 or (at
9  * your option) any later version. See the COPYING file in the top-level
10  * directory.
11  */
12 
13 #include "qemu/osdep.h"
14 #include CONFIG_DEVICES /* CONFIG_IOMMUFD */
15 #include <linux/vfio.h>
16 #include <sys/ioctl.h>
17 #include "qapi/error.h"
18 #include "hw/vfio/vfio-common.h"
19 #include "sysemu/iommufd.h"
20 #include "hw/s390x/ap-device.h"
21 #include "qemu/error-report.h"
22 #include "qemu/event_notifier.h"
23 #include "qemu/main-loop.h"
24 #include "qemu/module.h"
25 #include "qemu/option.h"
26 #include "qemu/config-file.h"
27 #include "kvm/kvm_s390x.h"
28 #include "migration/vmstate.h"
29 #include "hw/qdev-properties.h"
30 #include "hw/s390x/ap-bridge.h"
31 #include "exec/address-spaces.h"
32 #include "qom/object.h"
33 
34 #define TYPE_VFIO_AP_DEVICE      "vfio-ap"
35 
36 struct VFIOAPDevice {
37     APDevice apdev;
38     VFIODevice vdev;
39     EventNotifier req_notifier;
40 };
41 
42 OBJECT_DECLARE_SIMPLE_TYPE(VFIOAPDevice, VFIO_AP_DEVICE)
43 
44 static void vfio_ap_compute_needs_reset(VFIODevice *vdev)
45 {
46     vdev->needs_reset = false;
47 }
48 
49 /*
50  * We don't need vfio_hot_reset_multi and vfio_eoi operations for
51  * vfio-ap device now.
52  */
53 struct VFIODeviceOps vfio_ap_ops = {
54     .vfio_compute_needs_reset = vfio_ap_compute_needs_reset,
55 };
56 
57 static void vfio_ap_req_notifier_handler(void *opaque)
58 {
59     VFIOAPDevice *vapdev = opaque;
60     Error *err = NULL;
61 
62     if (!event_notifier_test_and_clear(&vapdev->req_notifier)) {
63         return;
64     }
65 
66     qdev_unplug(DEVICE(vapdev), &err);
67 
68     if (err) {
69         warn_reportf_err(err, VFIO_MSG_PREFIX, vapdev->vdev.name);
70     }
71 }
72 
73 static void vfio_ap_register_irq_notifier(VFIOAPDevice *vapdev,
74                                           unsigned int irq, Error **errp)
75 {
76     int fd;
77     size_t argsz;
78     IOHandler *fd_read;
79     EventNotifier *notifier;
80     struct vfio_irq_info *irq_info;
81     VFIODevice *vdev = &vapdev->vdev;
82 
83     switch (irq) {
84     case VFIO_AP_REQ_IRQ_INDEX:
85         notifier = &vapdev->req_notifier;
86         fd_read = vfio_ap_req_notifier_handler;
87         break;
88     default:
89         error_setg(errp, "vfio: Unsupported device irq(%d)", irq);
90         return;
91     }
92 
93     if (vdev->num_irqs < irq + 1) {
94         error_setg(errp, "vfio: IRQ %u not available (number of irqs %u)",
95                    irq, vdev->num_irqs);
96         return;
97     }
98 
99     argsz = sizeof(*irq_info);
100     irq_info = g_malloc0(argsz);
101     irq_info->index = irq;
102     irq_info->argsz = argsz;
103 
104     if (ioctl(vdev->fd, VFIO_DEVICE_GET_IRQ_INFO,
105               irq_info) < 0 || irq_info->count < 1) {
106         error_setg_errno(errp, errno, "vfio: Error getting irq info");
107         goto out_free_info;
108     }
109 
110     if (event_notifier_init(notifier, 0)) {
111         error_setg_errno(errp, errno,
112                          "vfio: Unable to init event notifier for irq (%d)",
113                          irq);
114         goto out_free_info;
115     }
116 
117     fd = event_notifier_get_fd(notifier);
118     qemu_set_fd_handler(fd, fd_read, NULL, vapdev);
119 
120     if (vfio_set_irq_signaling(vdev, irq, 0, VFIO_IRQ_SET_ACTION_TRIGGER, fd,
121                                errp)) {
122         qemu_set_fd_handler(fd, NULL, NULL, vapdev);
123         event_notifier_cleanup(notifier);
124     }
125 
126 out_free_info:
127     g_free(irq_info);
128 
129 }
130 
131 static void vfio_ap_unregister_irq_notifier(VFIOAPDevice *vapdev,
132                                             unsigned int irq)
133 {
134     Error *err = NULL;
135     EventNotifier *notifier;
136 
137     switch (irq) {
138     case VFIO_AP_REQ_IRQ_INDEX:
139         notifier = &vapdev->req_notifier;
140         break;
141     default:
142         error_report("vfio: Unsupported device irq(%d)", irq);
143         return;
144     }
145 
146     if (vfio_set_irq_signaling(&vapdev->vdev, irq, 0,
147                                VFIO_IRQ_SET_ACTION_TRIGGER, -1, &err)) {
148         warn_reportf_err(err, VFIO_MSG_PREFIX, vapdev->vdev.name);
149     }
150 
151     qemu_set_fd_handler(event_notifier_get_fd(notifier),
152                         NULL, NULL, vapdev);
153     event_notifier_cleanup(notifier);
154 }
155 
156 static void vfio_ap_realize(DeviceState *dev, Error **errp)
157 {
158     int ret;
159     Error *err = NULL;
160     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
161     VFIODevice *vbasedev = &vapdev->vdev;
162 
163     if (vfio_device_get_name(vbasedev, errp) < 0) {
164         return;
165     }
166 
167     ret = vfio_attach_device(vbasedev->name, vbasedev,
168                              &address_space_memory, errp);
169     if (ret) {
170         goto error;
171     }
172 
173     vfio_ap_register_irq_notifier(vapdev, VFIO_AP_REQ_IRQ_INDEX, &err);
174     if (err) {
175         /*
176          * Report this error, but do not make it a failing condition.
177          * Lack of this IRQ in the host does not prevent normal operation.
178          */
179         error_report_err(err);
180     }
181 
182     return;
183 
184 error:
185     error_prepend(errp, VFIO_MSG_PREFIX, vbasedev->name);
186     g_free(vbasedev->name);
187 }
188 
189 static void vfio_ap_unrealize(DeviceState *dev)
190 {
191     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
192 
193     vfio_ap_unregister_irq_notifier(vapdev, VFIO_AP_REQ_IRQ_INDEX);
194     vfio_detach_device(&vapdev->vdev);
195     g_free(vapdev->vdev.name);
196 }
197 
198 static Property vfio_ap_properties[] = {
199     DEFINE_PROP_STRING("sysfsdev", VFIOAPDevice, vdev.sysfsdev),
200 #ifdef CONFIG_IOMMUFD
201     DEFINE_PROP_LINK("iommufd", VFIOAPDevice, vdev.iommufd,
202                      TYPE_IOMMUFD_BACKEND, IOMMUFDBackend *),
203 #endif
204     DEFINE_PROP_END_OF_LIST(),
205 };
206 
207 static void vfio_ap_reset(DeviceState *dev)
208 {
209     int ret;
210     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
211 
212     ret = ioctl(vapdev->vdev.fd, VFIO_DEVICE_RESET);
213     if (ret) {
214         error_report("%s: failed to reset %s device: %s", __func__,
215                      vapdev->vdev.name, strerror(errno));
216     }
217 }
218 
219 static const VMStateDescription vfio_ap_vmstate = {
220     .name = "vfio-ap",
221     .unmigratable = 1,
222 };
223 
224 static void vfio_ap_instance_init(Object *obj)
225 {
226     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(obj);
227     VFIODevice *vbasedev = &vapdev->vdev;
228 
229     /*
230      * vfio-ap devices operate in a way compatible with discarding of
231      * memory in RAM blocks, as no pages are pinned in the host.
232      * This needs to be set before vfio_get_device() for vfio common to
233      * handle ram_block_discard_disable().
234      */
235     vfio_device_init(vbasedev, VFIO_DEVICE_TYPE_AP, &vfio_ap_ops,
236                      DEVICE(vapdev), true);
237 }
238 
239 #ifdef CONFIG_IOMMUFD
240 static void vfio_ap_set_fd(Object *obj, const char *str, Error **errp)
241 {
242     vfio_device_set_fd(&VFIO_AP_DEVICE(obj)->vdev, str, errp);
243 }
244 #endif
245 
246 static void vfio_ap_class_init(ObjectClass *klass, void *data)
247 {
248     DeviceClass *dc = DEVICE_CLASS(klass);
249 
250     device_class_set_props(dc, vfio_ap_properties);
251 #ifdef CONFIG_IOMMUFD
252     object_class_property_add_str(klass, "fd", NULL, vfio_ap_set_fd);
253 #endif
254     dc->vmsd = &vfio_ap_vmstate;
255     dc->desc = "VFIO-based AP device assignment";
256     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
257     dc->realize = vfio_ap_realize;
258     dc->unrealize = vfio_ap_unrealize;
259     dc->hotpluggable = true;
260     dc->reset = vfio_ap_reset;
261     dc->bus_type = TYPE_AP_BUS;
262 }
263 
264 static const TypeInfo vfio_ap_info = {
265     .name = TYPE_VFIO_AP_DEVICE,
266     .parent = TYPE_AP_DEVICE,
267     .instance_size = sizeof(VFIOAPDevice),
268     .instance_init = vfio_ap_instance_init,
269     .class_init = vfio_ap_class_init,
270 };
271 
272 static void vfio_ap_type_init(void)
273 {
274     type_register_static(&vfio_ap_info);
275 }
276 
277 type_init(vfio_ap_type_init)
278