hw/intc/s390_flic_kvm.c

   1 /*
   2  * QEMU S390x KVM floating interrupt controller (flic)
   3  *
   4  * Copyright 2014 IBM Corp.
   5  * Author(s): Jens Freimann <jfrei@linux.vnet.ibm.com>
   6  *            Cornelia Huck <cornelia.huck@de.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 <sys/ioctl.h>
  14 #include "qemu/error-report.h"
  15 #include "hw/sysbus.h"
  16 #include "sysemu/kvm.h"
  17 #include "migration/qemu-file.h"
  18 #include "hw/s390x/s390_flic.h"
  19 #include "hw/s390x/adapter.h"
  20 #include "trace.h"
  21
  22 #define FLIC_SAVE_INITIAL_SIZE getpagesize()
  23 #define FLIC_FAILED (-1UL)
  24 #define FLIC_SAVEVM_VERSION 1
  25
  26 typedef struct KVMS390FLICState {
  27     S390FLICState parent_obj;
  28
  29     uint32_t fd;
  30 } KVMS390FLICState;
  31
  32 DeviceState *s390_flic_kvm_create(void)
  33 {
  34     DeviceState *dev = NULL;
  35
  36     if (kvm_enabled()) {
  37         dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
  38         object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
  39                                   OBJECT(dev), NULL);
  40     }
  41     return dev;
  42 }
  43
  44 /**
  45  * flic_get_all_irqs - store all pending irqs in buffer
  46  * @buf: pointer to buffer which is passed to kernel
  47  * @len: length of buffer
  48  * @flic: pointer to flic device state
  49  *
  50  * Returns: -ENOMEM if buffer is too small,
  51  * -EINVAL if attr.group is invalid,
  52  * -EFAULT if copying to userspace failed,
  53  * on success return number of stored interrupts
  54  */
  55 static int flic_get_all_irqs(KVMS390FLICState *flic,
  56                              void *buf, int len)
  57 {
  58     struct kvm_device_attr attr = {
  59         .group = KVM_DEV_FLIC_GET_ALL_IRQS,
  60         .addr = (uint64_t) buf,
  61         .attr = len,
  62     };
  63     int rc;
  64
  65     rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
  66
  67     return rc == -1 ? -errno : rc;
  68 }
  69
  70 static void flic_enable_pfault(KVMS390FLICState *flic)
  71 {
  72     struct kvm_device_attr attr = {
  73         .group = KVM_DEV_FLIC_APF_ENABLE,
  74     };
  75     int rc;
  76
  77     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  78
  79     if (rc) {
  80         fprintf(stderr, "flic: couldn't enable pfault\n");
  81     }
  82 }
  83
  84 static void flic_disable_wait_pfault(KVMS390FLICState *flic)
  85 {
  86     struct kvm_device_attr attr = {
  87         .group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
  88     };
  89     int rc;
  90
  91     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  92
  93     if (rc) {
  94         fprintf(stderr, "flic: couldn't disable pfault\n");
  95     }
  96 }
  97
  98 /** flic_enqueue_irqs - returns 0 on success
  99  * @buf: pointer to buffer which is passed to kernel
 100  * @len: length of buffer
 101  * @flic: pointer to flic device state
 102  *
 103  * Returns: -EINVAL if attr.group is unknown
 104  */
 105 static int flic_enqueue_irqs(void *buf, uint64_t len,
 106                             KVMS390FLICState *flic)
 107 {
 108     int rc;
 109     struct kvm_device_attr attr = {
 110         .group = KVM_DEV_FLIC_ENQUEUE,
 111         .addr = (uint64_t) buf,
 112         .attr = len,
 113     };
 114
 115     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 116
 117     return rc ? -errno : 0;
 118 }
 119
 120 int kvm_s390_inject_flic(struct kvm_s390_irq *irq)
 121 {
 122     static KVMS390FLICState *flic;
 123
 124     if (unlikely(!flic)) {
 125         flic = KVM_S390_FLIC(s390_get_flic());
 126     }
 127     return flic_enqueue_irqs(irq, sizeof(*irq), flic);
 128 }
 129
 130 /**
 131  * __get_all_irqs - store all pending irqs in buffer
 132  * @flic: pointer to flic device state
 133  * @buf: pointer to pointer to a buffer
 134  * @len: length of buffer
 135  *
 136  * Returns: return value of flic_get_all_irqs
 137  * Note: Retry and increase buffer size until flic_get_all_irqs
 138  * either returns a value >= 0 or a negative error code.
 139  * -ENOMEM is an exception, which means the buffer is too small
 140  * and we should try again. Other negative error codes can be
 141  * -EFAULT and -EINVAL which we ignore at this point
 142  */
 143 static int __get_all_irqs(KVMS390FLICState *flic,
 144                           void **buf, int len)
 145 {
 146     int r;
 147
 148     do {
 149         /* returns -ENOMEM if buffer is too small and number
 150          * of queued interrupts on success */
 151         r = flic_get_all_irqs(flic, *buf, len);
 152         if (r >= 0) {
 153             break;
 154         }
 155         len *= 2;
 156         *buf = g_try_realloc(*buf, len);
 157         if (!buf) {
 158             return -ENOMEM;
 159         }
 160     } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
 161
 162     return r;
 163 }
 164
 165 static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
 166                                         uint8_t isc, bool swap,
 167                                         bool is_maskable)
 168 {
 169     struct kvm_s390_io_adapter adapter = {
 170         .id = id,
 171         .isc = isc,
 172         .maskable = is_maskable,
 173         .swap = swap,
 174     };
 175     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 176     int r, ret;
 177     struct kvm_device_attr attr = {
 178         .group = KVM_DEV_FLIC_ADAPTER_REGISTER,
 179         .addr = (uint64_t)&adapter,
 180     };
 181
 182     if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
 183         /* nothing to do */
 184         return 0;
 185     }
 186
 187     r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 188
 189     ret = r ? -errno : 0;
 190     return ret;
 191 }
 192
 193 static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
 194                                    uint64_t map_addr, bool do_map)
 195 {
 196     struct kvm_s390_io_adapter_req req = {
 197         .id = id,
 198         .type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
 199         .addr = map_addr,
 200     };
 201     struct kvm_device_attr attr = {
 202         .group = KVM_DEV_FLIC_ADAPTER_MODIFY,
 203         .addr = (uint64_t)&req,
 204     };
 205     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 206     int r;
 207
 208     if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
 209         /* nothing to do */
 210         return 0;
 211     }
 212
 213     r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 214     return r ? -errno : 0;
 215 }
 216
 217 static int kvm_s390_add_adapter_routes(S390FLICState *fs,
 218                                        AdapterRoutes *routes)
 219 {
 220     int ret, i;
 221     uint64_t ind_offset = routes->adapter.ind_offset;
 222
 223     for (i = 0; i < routes->num_routes; i++) {
 224         ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter);
 225         if (ret < 0) {
 226             goto out_undo;
 227         }
 228         routes->gsi[i] = ret;
 229         routes->adapter.ind_offset++;
 230     }
 231     kvm_irqchip_commit_routes(kvm_state);
 232
 233     /* Restore passed-in structure to original state. */
 234     routes->adapter.ind_offset = ind_offset;
 235     return 0;
 236 out_undo:
 237     while (--i >= 0) {
 238         kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
 239         routes->gsi[i] = -1;
 240     }
 241     routes->adapter.ind_offset = ind_offset;
 242     return ret;
 243 }
 244
 245 static void kvm_s390_release_adapter_routes(S390FLICState *fs,
 246                                             AdapterRoutes *routes)
 247 {
 248     int i;
 249
 250     for (i = 0; i < routes->num_routes; i++) {
 251         if (routes->gsi[i] >= 0) {
 252             kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
 253             routes->gsi[i] = -1;
 254         }
 255     }
 256 }
 257
 258 /**
 259  * kvm_flic_save - Save pending floating interrupts
 260  * @f: QEMUFile containing migration state
 261  * @opaque: pointer to flic device state
 262  *
 263  * Note: Pass buf and len to kernel. Start with one page and
 264  * increase until buffer is sufficient or maxium size is
 265  * reached
 266  */
 267 static void kvm_flic_save(QEMUFile *f, void *opaque)
 268 {
 269     KVMS390FLICState *flic = opaque;
 270     int len = FLIC_SAVE_INITIAL_SIZE;
 271     void *buf;
 272     int count;
 273
 274     flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
 275
 276     buf = g_try_malloc0(len);
 277     if (!buf) {
 278         /* Storing FLIC_FAILED into the count field here will cause the
 279          * target system to fail when attempting to load irqs from the
 280          * migration state */
 281         error_report("flic: couldn't allocate memory");
 282         qemu_put_be64(f, FLIC_FAILED);
 283         return;
 284     }
 285
 286     count = __get_all_irqs(flic, &buf, len);
 287     if (count < 0) {
 288         error_report("flic: couldn't retrieve irqs from kernel, rc %d",
 289                      count);
 290         /* Storing FLIC_FAILED into the count field here will cause the
 291          * target system to fail when attempting to load irqs from the
 292          * migration state */
 293         qemu_put_be64(f, FLIC_FAILED);
 294     } else {
 295         qemu_put_be64(f, count);
 296         qemu_put_buffer(f, (uint8_t *) buf,
 297                         count * sizeof(struct kvm_s390_irq));
 298     }
 299     g_free(buf);
 300 }
 301
 302 /**
 303  * kvm_flic_load - Load pending floating interrupts
 304  * @f: QEMUFile containing migration state
 305  * @opaque: pointer to flic device state
 306  * @version_id: version id for migration
 307  *
 308  * Returns: value of flic_enqueue_irqs, -EINVAL on error
 309  * Note: Do nothing when no interrupts where stored
 310  * in QEMUFile
 311  */
 312 static int kvm_flic_load(QEMUFile *f, void *opaque, int version_id)
 313 {
 314     uint64_t len = 0;
 315     uint64_t count = 0;
 316     void *buf = NULL;
 317     int r = 0;
 318
 319     if (version_id != FLIC_SAVEVM_VERSION) {
 320         r = -EINVAL;
 321         goto out;
 322     }
 323
 324     flic_enable_pfault((struct KVMS390FLICState *) opaque);
 325
 326     count = qemu_get_be64(f);
 327     len = count * sizeof(struct kvm_s390_irq);
 328     if (count == FLIC_FAILED) {
 329         r = -EINVAL;
 330         goto out;
 331     }
 332     if (count == 0) {
 333         r = 0;
 334         goto out;
 335     }
 336     buf = g_try_malloc0(len);
 337     if (!buf) {
 338         r = -ENOMEM;
 339         goto out;
 340     }
 341
 342     if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
 343         r = -EINVAL;
 344         goto out_free;
 345     }
 346     r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
 347
 348 out_free:
 349     g_free(buf);
 350 out:
 351     return r;
 352 }
 353
 354 static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
 355 {
 356     KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
 357     struct kvm_create_device cd = {0};
 358     int ret;
 359
 360     flic_state->fd = -1;
 361     if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
 362         trace_flic_no_device_api(errno);
 363         return;
 364     }
 365
 366     cd.type = KVM_DEV_TYPE_FLIC;
 367     ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
 368     if (ret < 0) {
 369         trace_flic_create_device(errno);
 370         return;
 371     }
 372     flic_state->fd = cd.fd;
 373
 374     /* Register savevm handler for floating interrupts */
 375     register_savevm(NULL, "s390-flic", 0, 1, kvm_flic_save,
 376                     kvm_flic_load, (void *) flic_state);
 377 }
 378
 379 static void kvm_s390_flic_unrealize(DeviceState *dev, Error **errp)
 380 {
 381     KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
 382
 383     unregister_savevm(DEVICE(flic_state), "s390-flic", flic_state);
 384 }
 385
 386 static void kvm_s390_flic_reset(DeviceState *dev)
 387 {
 388     KVMS390FLICState *flic = KVM_S390_FLIC(dev);
 389     struct kvm_device_attr attr = {
 390         .group = KVM_DEV_FLIC_CLEAR_IRQS,
 391     };
 392     int rc = 0;
 393
 394     if (flic->fd == -1) {
 395         return;
 396     }
 397
 398     flic_disable_wait_pfault(flic);
 399
 400     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 401     if (rc) {
 402         trace_flic_reset_failed(errno);
 403     }
 404
 405     flic_enable_pfault(flic);
 406 }
 407
 408 static void kvm_s390_flic_class_init(ObjectClass *oc, void *data)
 409 {
 410     DeviceClass *dc = DEVICE_CLASS(oc);
 411     S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
 412
 413     dc->realize = kvm_s390_flic_realize;
 414     dc->unrealize = kvm_s390_flic_unrealize;
 415     dc->reset = kvm_s390_flic_reset;
 416     fsc->register_io_adapter = kvm_s390_register_io_adapter;
 417     fsc->io_adapter_map = kvm_s390_io_adapter_map;
 418     fsc->add_adapter_routes = kvm_s390_add_adapter_routes;
 419     fsc->release_adapter_routes = kvm_s390_release_adapter_routes;
 420 }
 421
 422 static const TypeInfo kvm_s390_flic_info = {
 423     .name          = TYPE_KVM_S390_FLIC,
 424     .parent        = TYPE_S390_FLIC_COMMON,
 425     .instance_size = sizeof(KVMS390FLICState),
 426     .class_init    = kvm_s390_flic_class_init,
 427 };
 428
 429 static void kvm_s390_flic_register_types(void)
 430 {
 431     type_register_static(&kvm_s390_flic_info);
 432 }
 433
 434 type_init(kvm_s390_flic_register_types)