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 "qemu/osdep.h"
  14 #include "qemu-common.h"
  15 #include "cpu.h"
  16 #include <sys/ioctl.h>
  17 #include "qemu/error-report.h"
  18 #include "qapi/error.h"
  19 #include "hw/sysbus.h"
  20 #include "sysemu/kvm.h"
  21 #include "hw/s390x/s390_flic.h"
  22 #include "hw/s390x/adapter.h"
  23 #include "hw/s390x/css.h"
  24 #include "trace.h"
  25
  26 #define FLIC_SAVE_INITIAL_SIZE getpagesize()
  27 #define FLIC_FAILED (-1UL)
  28 #define FLIC_SAVEVM_VERSION 1
  29
  30 typedef struct KVMS390FLICState {
  31     S390FLICState parent_obj;
  32
  33     uint32_t fd;
  34     bool clear_io_supported;
  35 } KVMS390FLICState;
  36
  37 DeviceState *s390_flic_kvm_create(void)
  38 {
  39     DeviceState *dev = NULL;
  40
  41     if (kvm_enabled()) {
  42         dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
  43         object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
  44                                   OBJECT(dev), NULL);
  45     }
  46     return dev;
  47 }
  48
  49 /**
  50  * flic_get_all_irqs - store all pending irqs in buffer
  51  * @buf: pointer to buffer which is passed to kernel
  52  * @len: length of buffer
  53  * @flic: pointer to flic device state
  54  *
  55  * Returns: -ENOMEM if buffer is too small,
  56  * -EINVAL if attr.group is invalid,
  57  * -EFAULT if copying to userspace failed,
  58  * on success return number of stored interrupts
  59  */
  60 static int flic_get_all_irqs(KVMS390FLICState *flic,
  61                              void *buf, int len)
  62 {
  63     struct kvm_device_attr attr = {
  64         .group = KVM_DEV_FLIC_GET_ALL_IRQS,
  65         .addr = (uint64_t) buf,
  66         .attr = len,
  67     };
  68     int rc;
  69
  70     rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
  71
  72     return rc == -1 ? -errno : rc;
  73 }
  74
  75 static void flic_enable_pfault(KVMS390FLICState *flic)
  76 {
  77     struct kvm_device_attr attr = {
  78         .group = KVM_DEV_FLIC_APF_ENABLE,
  79     };
  80     int rc;
  81
  82     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  83
  84     if (rc) {
  85         fprintf(stderr, "flic: couldn't enable pfault\n");
  86     }
  87 }
  88
  89 static void flic_disable_wait_pfault(KVMS390FLICState *flic)
  90 {
  91     struct kvm_device_attr attr = {
  92         .group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
  93     };
  94     int rc;
  95
  96     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  97
  98     if (rc) {
  99         fprintf(stderr, "flic: couldn't disable pfault\n");
 100     }
 101 }
 102
 103 /** flic_enqueue_irqs - returns 0 on success
 104  * @buf: pointer to buffer which is passed to kernel
 105  * @len: length of buffer
 106  * @flic: pointer to flic device state
 107  *
 108  * Returns: -EINVAL if attr.group is unknown
 109  */
 110 static int flic_enqueue_irqs(void *buf, uint64_t len,
 111                             KVMS390FLICState *flic)
 112 {
 113     int rc;
 114     struct kvm_device_attr attr = {
 115         .group = KVM_DEV_FLIC_ENQUEUE,
 116         .addr = (uint64_t) buf,
 117         .attr = len,
 118     };
 119
 120     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 121
 122     return rc ? -errno : 0;
 123 }
 124
 125 int kvm_s390_inject_flic(struct kvm_s390_irq *irq)
 126 {
 127     static KVMS390FLICState *flic;
 128
 129     if (unlikely(!flic)) {
 130         flic = KVM_S390_FLIC(s390_get_flic());
 131     }
 132     return flic_enqueue_irqs(irq, sizeof(*irq), flic);
 133 }
 134
 135 static int kvm_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id,
 136                            uint16_t subchannel_nr)
 137 {
 138     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 139     int rc;
 140     uint32_t sid = subchannel_id << 16 | subchannel_nr;
 141     struct kvm_device_attr attr = {
 142         .group = KVM_DEV_FLIC_CLEAR_IO_IRQ,
 143         .addr = (uint64_t) &sid,
 144         .attr = sizeof(sid),
 145     };
 146     if (unlikely(!flic->clear_io_supported)) {
 147         return -ENOSYS;
 148     }
 149     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 150     return rc ? -errno : 0;
 151 }
 152
 153 static int kvm_s390_modify_ais_mode(S390FLICState *fs, uint8_t isc,
 154                                     uint16_t mode)
 155 {
 156     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 157     struct kvm_s390_ais_req req = {
 158         .isc = isc,
 159         .mode = mode,
 160     };
 161     struct kvm_device_attr attr = {
 162         .group = KVM_DEV_FLIC_AISM,
 163         .addr = (uint64_t)&req,
 164     };
 165
 166     if (!fs->ais_supported) {
 167         return -ENOSYS;
 168     }
 169
 170     return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0;
 171 }
 172
 173 static int kvm_s390_inject_airq(S390FLICState *fs, uint8_t type,
 174                                 uint8_t isc, uint8_t flags)
 175 {
 176     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 177     uint32_t id = css_get_adapter_id(type, isc);
 178     struct kvm_device_attr attr = {
 179         .group = KVM_DEV_FLIC_AIRQ_INJECT,
 180         .attr = id,
 181     };
 182
 183     if (!fs->ais_supported) {
 184         return -ENOSYS;
 185     }
 186
 187     return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0;
 188 }
 189
 190 /**
 191  * __get_all_irqs - store all pending irqs in buffer
 192  * @flic: pointer to flic device state
 193  * @buf: pointer to pointer to a buffer
 194  * @len: length of buffer
 195  *
 196  * Returns: return value of flic_get_all_irqs
 197  * Note: Retry and increase buffer size until flic_get_all_irqs
 198  * either returns a value >= 0 or a negative error code.
 199  * -ENOMEM is an exception, which means the buffer is too small
 200  * and we should try again. Other negative error codes can be
 201  * -EFAULT and -EINVAL which we ignore at this point
 202  */
 203 static int __get_all_irqs(KVMS390FLICState *flic,
 204                           void **buf, int len)
 205 {
 206     int r;
 207
 208     do {
 209         /* returns -ENOMEM if buffer is too small and number
 210          * of queued interrupts on success */
 211         r = flic_get_all_irqs(flic, *buf, len);
 212         if (r >= 0) {
 213             break;
 214         }
 215         len *= 2;
 216         *buf = g_try_realloc(*buf, len);
 217         if (!buf) {
 218             return -ENOMEM;
 219         }
 220     } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
 221
 222     return r;
 223 }
 224
 225 static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
 226                                         uint8_t isc, bool swap,
 227                                         bool is_maskable, uint8_t flags)
 228 {
 229     struct kvm_s390_io_adapter adapter = {
 230         .id = id,
 231         .isc = isc,
 232         .maskable = is_maskable,
 233         .swap = swap,
 234         .flags = flags,
 235     };
 236     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 237     int r;
 238     struct kvm_device_attr attr = {
 239         .group = KVM_DEV_FLIC_ADAPTER_REGISTER,
 240         .addr = (uint64_t)&adapter,
 241     };
 242
 243     if (!kvm_gsi_routing_enabled()) {
 244         /* nothing to do */
 245         return 0;
 246     }
 247
 248     r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 249
 250     return r ? -errno : 0;
 251 }
 252
 253 static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
 254                                    uint64_t map_addr, bool do_map)
 255 {
 256     struct kvm_s390_io_adapter_req req = {
 257         .id = id,
 258         .type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
 259         .addr = map_addr,
 260     };
 261     struct kvm_device_attr attr = {
 262         .group = KVM_DEV_FLIC_ADAPTER_MODIFY,
 263         .addr = (uint64_t)&req,
 264     };
 265     KVMS390FLICState *flic = KVM_S390_FLIC(fs);
 266     int r;
 267
 268     if (!kvm_gsi_routing_enabled()) {
 269         /* nothing to do */
 270         return 0;
 271     }
 272
 273     r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 274     return r ? -errno : 0;
 275 }
 276
 277 static int kvm_s390_add_adapter_routes(S390FLICState *fs,
 278                                        AdapterRoutes *routes)
 279 {
 280     int ret, i;
 281     uint64_t ind_offset = routes->adapter.ind_offset;
 282
 283     for (i = 0; i < routes->num_routes; i++) {
 284         ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter);
 285         if (ret < 0) {
 286             goto out_undo;
 287         }
 288         routes->gsi[i] = ret;
 289         routes->adapter.ind_offset++;
 290     }
 291     kvm_irqchip_commit_routes(kvm_state);
 292
 293     /* Restore passed-in structure to original state. */
 294     routes->adapter.ind_offset = ind_offset;
 295     return 0;
 296 out_undo:
 297     while (--i >= 0) {
 298         kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
 299         routes->gsi[i] = -1;
 300     }
 301     routes->adapter.ind_offset = ind_offset;
 302     return ret;
 303 }
 304
 305 static void kvm_s390_release_adapter_routes(S390FLICState *fs,
 306                                             AdapterRoutes *routes)
 307 {
 308     int i;
 309
 310     for (i = 0; i < routes->num_routes; i++) {
 311         if (routes->gsi[i] >= 0) {
 312             kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
 313             routes->gsi[i] = -1;
 314         }
 315     }
 316 }
 317
 318 /**
 319  * kvm_flic_save - Save pending floating interrupts
 320  * @f: QEMUFile containing migration state
 321  * @opaque: pointer to flic device state
 322  * @size: ignored
 323  *
 324  * Note: Pass buf and len to kernel. Start with one page and
 325  * increase until buffer is sufficient or maxium size is
 326  * reached
 327  */
 328 static int kvm_flic_save(QEMUFile *f, void *opaque, size_t size,
 329                          VMStateField *field, QJSON *vmdesc)
 330 {
 331     KVMS390FLICState *flic = opaque;
 332     int len = FLIC_SAVE_INITIAL_SIZE;
 333     void *buf;
 334     int count;
 335     int r = 0;
 336
 337     flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
 338
 339     buf = g_try_malloc0(len);
 340     if (!buf) {
 341         /* Storing FLIC_FAILED into the count field here will cause the
 342          * target system to fail when attempting to load irqs from the
 343          * migration state */
 344         error_report("flic: couldn't allocate memory");
 345         qemu_put_be64(f, FLIC_FAILED);
 346         return -ENOMEM;
 347     }
 348
 349     count = __get_all_irqs(flic, &buf, len);
 350     if (count < 0) {
 351         error_report("flic: couldn't retrieve irqs from kernel, rc %d",
 352                      count);
 353         /* Storing FLIC_FAILED into the count field here will cause the
 354          * target system to fail when attempting to load irqs from the
 355          * migration state */
 356         qemu_put_be64(f, FLIC_FAILED);
 357         r = count;
 358     } else {
 359         qemu_put_be64(f, count);
 360         qemu_put_buffer(f, (uint8_t *) buf,
 361                         count * sizeof(struct kvm_s390_irq));
 362     }
 363     g_free(buf);
 364
 365     return r;
 366 }
 367
 368 /**
 369  * kvm_flic_load - Load pending floating interrupts
 370  * @f: QEMUFile containing migration state
 371  * @opaque: pointer to flic device state
 372  * @size: ignored
 373  *
 374  * Returns: value of flic_enqueue_irqs, -EINVAL on error
 375  * Note: Do nothing when no interrupts where stored
 376  * in QEMUFile
 377  */
 378 static int kvm_flic_load(QEMUFile *f, void *opaque, size_t size,
 379                          VMStateField *field)
 380 {
 381     uint64_t len = 0;
 382     uint64_t count = 0;
 383     void *buf = NULL;
 384     int r = 0;
 385
 386     flic_enable_pfault((struct KVMS390FLICState *) opaque);
 387
 388     count = qemu_get_be64(f);
 389     len = count * sizeof(struct kvm_s390_irq);
 390     if (count == FLIC_FAILED) {
 391         r = -EINVAL;
 392         goto out;
 393     }
 394     if (count == 0) {
 395         r = 0;
 396         goto out;
 397     }
 398     buf = g_try_malloc0(len);
 399     if (!buf) {
 400         r = -ENOMEM;
 401         goto out;
 402     }
 403
 404     if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
 405         r = -EINVAL;
 406         goto out_free;
 407     }
 408     r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
 409
 410 out_free:
 411     g_free(buf);
 412 out:
 413     return r;
 414 }
 415
 416 static const VMStateDescription kvm_s390_flic_vmstate = {
 417     .name = "s390-flic",
 418     .version_id = FLIC_SAVEVM_VERSION,
 419     .minimum_version_id = FLIC_SAVEVM_VERSION,
 420     .fields = (VMStateField[]) {
 421         {
 422             .name = "irqs",
 423             .info = &(const VMStateInfo) {
 424                 .name = "irqs",
 425                 .get = kvm_flic_load,
 426                 .put = kvm_flic_save,
 427             },
 428             .flags = VMS_SINGLE,
 429         },
 430         VMSTATE_END_OF_LIST()
 431     }
 432 };
 433
 434 typedef struct KVMS390FLICStateClass {
 435     S390FLICStateClass parent_class;
 436     DeviceRealize parent_realize;
 437 } KVMS390FLICStateClass;
 438
 439 #define KVM_S390_FLIC_GET_CLASS(obj) \
 440     OBJECT_GET_CLASS(KVMS390FLICStateClass, (obj), TYPE_KVM_S390_FLIC)
 441
 442 #define KVM_S390_FLIC_CLASS(klass) \
 443     OBJECT_CLASS_CHECK(KVMS390FLICStateClass, (klass), TYPE_KVM_S390_FLIC)
 444
 445 static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
 446 {
 447     S390FLICState *fs = S390_FLIC_COMMON(dev);
 448     KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
 449     struct kvm_create_device cd = {0};
 450     struct kvm_device_attr test_attr = {0};
 451     int ret;
 452     Error *errp_local = NULL;
 453
 454     KVM_S390_FLIC_GET_CLASS(dev)->parent_realize(dev, &errp_local);
 455     if (errp_local) {
 456         goto fail;
 457     }
 458     flic_state->fd = -1;
 459     if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
 460         error_setg_errno(&errp_local, errno, "KVM is missing capability"
 461                          " KVM_CAP_DEVICE_CTRL");
 462         trace_flic_no_device_api(errno);
 463         goto fail;
 464     }
 465
 466     cd.type = KVM_DEV_TYPE_FLIC;
 467     ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
 468     if (ret < 0) {
 469         error_setg_errno(&errp_local, errno, "Creating the KVM device failed");
 470         trace_flic_create_device(errno);
 471         goto fail;
 472     }
 473     flic_state->fd = cd.fd;
 474
 475     /* Check clear_io_irq support */
 476     test_attr.group = KVM_DEV_FLIC_CLEAR_IO_IRQ;
 477     flic_state->clear_io_supported = !ioctl(flic_state->fd,
 478                                             KVM_HAS_DEVICE_ATTR, test_attr);
 479
 480     fs->ais_supported = false;
 481     return;
 482 fail:
 483     error_propagate(errp, errp_local);
 484 }
 485
 486 static void kvm_s390_flic_reset(DeviceState *dev)
 487 {
 488     KVMS390FLICState *flic = KVM_S390_FLIC(dev);
 489     S390FLICState *fs = S390_FLIC_COMMON(dev);
 490     struct kvm_device_attr attr = {
 491         .group = KVM_DEV_FLIC_CLEAR_IRQS,
 492     };
 493     int rc = 0;
 494     uint8_t isc;
 495
 496     if (flic->fd == -1) {
 497         return;
 498     }
 499
 500     flic_disable_wait_pfault(flic);
 501
 502     if (fs->ais_supported) {
 503         for (isc = 0; isc <= MAX_ISC; isc++) {
 504             rc = kvm_s390_modify_ais_mode(fs, isc, SIC_IRQ_MODE_ALL);
 505             if (rc) {
 506                 error_report("Failed to reset ais mode for isc %d: %s",
 507                              isc, strerror(-rc));
 508             }
 509         }
 510     }
 511
 512     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 513     if (rc) {
 514         trace_flic_reset_failed(errno);
 515     }
 516
 517     flic_enable_pfault(flic);
 518 }
 519
 520 static void kvm_s390_flic_class_init(ObjectClass *oc, void *data)
 521 {
 522     DeviceClass *dc = DEVICE_CLASS(oc);
 523     S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
 524
 525     KVM_S390_FLIC_CLASS(oc)->parent_realize = dc->realize;
 526     dc->realize = kvm_s390_flic_realize;
 527     dc->vmsd = &kvm_s390_flic_vmstate;
 528     dc->reset = kvm_s390_flic_reset;
 529     fsc->register_io_adapter = kvm_s390_register_io_adapter;
 530     fsc->io_adapter_map = kvm_s390_io_adapter_map;
 531     fsc->add_adapter_routes = kvm_s390_add_adapter_routes;
 532     fsc->release_adapter_routes = kvm_s390_release_adapter_routes;
 533     fsc->clear_io_irq = kvm_s390_clear_io_flic;
 534     fsc->modify_ais_mode = kvm_s390_modify_ais_mode;
 535     fsc->inject_airq = kvm_s390_inject_airq;
 536 }
 537
 538 static const TypeInfo kvm_s390_flic_info = {
 539     .name          = TYPE_KVM_S390_FLIC,
 540     .parent        = TYPE_S390_FLIC_COMMON,
 541     .instance_size = sizeof(KVMS390FLICState),
 542     .class_size    = sizeof(KVMS390FLICStateClass),
 543     .class_init    = kvm_s390_flic_class_init,
 544 };
 545
 546 static void kvm_s390_flic_register_types(void)
 547 {
 548     type_register_static(&kvm_s390_flic_info);
 549 }
 550
 551 type_init(kvm_s390_flic_register_types)