hw/vfio/ap.c

   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     ERRP_GUARD();
 159     int ret;
 160     Error *err = NULL;
 161     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
 162     VFIODevice *vbasedev = &vapdev->vdev;
 163
 164     if (vfio_device_get_name(vbasedev, errp) < 0) {
 165         return;
 166     }
 167
 168     ret = vfio_attach_device(vbasedev->name, vbasedev,
 169                              &address_space_memory, errp);
 170     if (ret) {
 171         goto error;
 172     }
 173
 174     vfio_ap_register_irq_notifier(vapdev, VFIO_AP_REQ_IRQ_INDEX, &err);
 175     if (err) {
 176         /*
 177          * Report this error, but do not make it a failing condition.
 178          * Lack of this IRQ in the host does not prevent normal operation.
 179          */
 180         error_report_err(err);
 181     }
 182
 183     return;
 184
 185 error:
 186     error_prepend(errp, VFIO_MSG_PREFIX, vbasedev->name);
 187     g_free(vbasedev->name);
 188 }
 189
 190 static void vfio_ap_unrealize(DeviceState *dev)
 191 {
 192     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
 193
 194     vfio_ap_unregister_irq_notifier(vapdev, VFIO_AP_REQ_IRQ_INDEX);
 195     vfio_detach_device(&vapdev->vdev);
 196     g_free(vapdev->vdev.name);
 197 }
 198
 199 static Property vfio_ap_properties[] = {
 200     DEFINE_PROP_STRING("sysfsdev", VFIOAPDevice, vdev.sysfsdev),
 201 #ifdef CONFIG_IOMMUFD
 202     DEFINE_PROP_LINK("iommufd", VFIOAPDevice, vdev.iommufd,
 203                      TYPE_IOMMUFD_BACKEND, IOMMUFDBackend *),
 204 #endif
 205     DEFINE_PROP_END_OF_LIST(),
 206 };
 207
 208 static void vfio_ap_reset(DeviceState *dev)
 209 {
 210     int ret;
 211     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(dev);
 212
 213     ret = ioctl(vapdev->vdev.fd, VFIO_DEVICE_RESET);
 214     if (ret) {
 215         error_report("%s: failed to reset %s device: %s", __func__,
 216                      vapdev->vdev.name, strerror(errno));
 217     }
 218 }
 219
 220 static const VMStateDescription vfio_ap_vmstate = {
 221     .name = "vfio-ap",
 222     .unmigratable = 1,
 223 };
 224
 225 static void vfio_ap_instance_init(Object *obj)
 226 {
 227     VFIOAPDevice *vapdev = VFIO_AP_DEVICE(obj);
 228     VFIODevice *vbasedev = &vapdev->vdev;
 229
 230     /*
 231      * vfio-ap devices operate in a way compatible with discarding of
 232      * memory in RAM blocks, as no pages are pinned in the host.
 233      * This needs to be set before vfio_get_device() for vfio common to
 234      * handle ram_block_discard_disable().
 235      */
 236     vfio_device_init(vbasedev, VFIO_DEVICE_TYPE_AP, &vfio_ap_ops,
 237                      DEVICE(vapdev), true);
 238 }
 239
 240 #ifdef CONFIG_IOMMUFD
 241 static void vfio_ap_set_fd(Object *obj, const char *str, Error **errp)
 242 {
 243     vfio_device_set_fd(&VFIO_AP_DEVICE(obj)->vdev, str, errp);
 244 }
 245 #endif
 246
 247 static void vfio_ap_class_init(ObjectClass *klass, void *data)
 248 {
 249     DeviceClass *dc = DEVICE_CLASS(klass);
 250
 251     device_class_set_props(dc, vfio_ap_properties);
 252 #ifdef CONFIG_IOMMUFD
 253     object_class_property_add_str(klass, "fd", NULL, vfio_ap_set_fd);
 254 #endif
 255     dc->vmsd = &vfio_ap_vmstate;
 256     dc->desc = "VFIO-based AP device assignment";
 257     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 258     dc->realize = vfio_ap_realize;
 259     dc->unrealize = vfio_ap_unrealize;
 260     dc->hotpluggable = true;
 261     dc->reset = vfio_ap_reset;
 262     dc->bus_type = TYPE_AP_BUS;
 263 }
 264
 265 static const TypeInfo vfio_ap_info = {
 266     .name = TYPE_VFIO_AP_DEVICE,
 267     .parent = TYPE_AP_DEVICE,
 268     .instance_size = sizeof(VFIOAPDevice),
 269     .instance_init = vfio_ap_instance_init,
 270     .class_init = vfio_ap_class_init,
 271 };
 272
 273 static void vfio_ap_type_init(void)
 274 {
 275     type_register_static(&vfio_ap_info);
 276 }
 277
 278 type_init(vfio_ap_type_init)