hw/intc/s390_flic.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  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or (at
   8  * your option) any later version. See the COPYING file in the top-level
   9  * directory.
  10  */
  11
  12 #include <sys/ioctl.h>
  13 #include "qemu/error-report.h"
  14 #include "hw/sysbus.h"
  15 #include "sysemu/kvm.h"
  16 #include "migration/qemu-file.h"
  17 #include "hw/s390x/s390_flic.h"
  18 #include "trace.h"
  19
  20 #define FLIC_SAVE_INITIAL_SIZE getpagesize()
  21 #define FLIC_FAILED (-1UL)
  22 #define FLIC_SAVEVM_VERSION 1
  23
  24 void s390_flic_init(void)
  25 {
  26     DeviceState *dev;
  27     int r;
  28
  29     if (kvm_enabled()) {
  30         dev = qdev_create(NULL, "s390-flic");
  31         object_property_add_child(qdev_get_machine(), "s390-flic",
  32                                 OBJECT(dev), NULL);
  33         r = qdev_init(dev);
  34         if (r) {
  35             error_report("flic: couldn't create qdev");
  36         }
  37     }
  38 }
  39
  40 /**
  41  * flic_get_all_irqs - store all pending irqs in buffer
  42  * @buf: pointer to buffer which is passed to kernel
  43  * @len: length of buffer
  44  * @flic: pointer to flic device state
  45  *
  46  * Returns: -ENOMEM if buffer is too small,
  47  * -EINVAL if attr.group is invalid,
  48  * -EFAULT if copying to userspace failed,
  49  * on success return number of stored interrupts
  50  */
  51 static int flic_get_all_irqs(KVMS390FLICState *flic,
  52                              void *buf, int len)
  53 {
  54     struct kvm_device_attr attr = {
  55         .group = KVM_DEV_FLIC_GET_ALL_IRQS,
  56         .addr = (uint64_t) buf,
  57         .attr = len,
  58     };
  59     int rc;
  60
  61     rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
  62
  63     return rc == -1 ? -errno : rc;
  64 }
  65
  66 static void flic_enable_pfault(KVMS390FLICState *flic)
  67 {
  68     struct kvm_device_attr attr = {
  69         .group = KVM_DEV_FLIC_APF_ENABLE,
  70     };
  71     int rc;
  72
  73     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  74
  75     if (rc) {
  76         fprintf(stderr, "flic: couldn't enable pfault\n");
  77     }
  78 }
  79
  80 static void flic_disable_wait_pfault(KVMS390FLICState *flic)
  81 {
  82     struct kvm_device_attr attr = {
  83         .group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
  84     };
  85     int rc;
  86
  87     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
  88
  89     if (rc) {
  90         fprintf(stderr, "flic: couldn't disable pfault\n");
  91     }
  92 }
  93
  94 /** flic_enqueue_irqs - returns 0 on success
  95  * @buf: pointer to buffer which is passed to kernel
  96  * @len: length of buffer
  97  * @flic: pointer to flic device state
  98  *
  99  * Returns: -EINVAL if attr.group is unknown
 100  */
 101 static int flic_enqueue_irqs(void *buf, uint64_t len,
 102                             KVMS390FLICState *flic)
 103 {
 104     int rc;
 105     struct kvm_device_attr attr = {
 106         .group = KVM_DEV_FLIC_ENQUEUE,
 107         .addr = (uint64_t) buf,
 108         .attr = len,
 109     };
 110
 111     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 112
 113     return rc ? -errno : 0;
 114 }
 115
 116 /**
 117  * __get_all_irqs - store all pending irqs in buffer
 118  * @flic: pointer to flic device state
 119  * @buf: pointer to pointer to a buffer
 120  * @len: length of buffer
 121  *
 122  * Returns: return value of flic_get_all_irqs
 123  * Note: Retry and increase buffer size until flic_get_all_irqs
 124  * either returns a value >= 0 or a negative error code.
 125  * -ENOMEM is an exception, which means the buffer is too small
 126  * and we should try again. Other negative error codes can be
 127  * -EFAULT and -EINVAL which we ignore at this point
 128  */
 129 static int __get_all_irqs(KVMS390FLICState *flic,
 130                           void **buf, int len)
 131 {
 132     int r;
 133
 134     do {
 135         /* returns -ENOMEM if buffer is too small and number
 136          * of queued interrupts on success */
 137         r = flic_get_all_irqs(flic, *buf, len);
 138         if (r >= 0) {
 139             break;
 140         }
 141         len *= 2;
 142         *buf = g_try_realloc(*buf, len);
 143         if (!buf) {
 144             return -ENOMEM;
 145         }
 146     } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
 147
 148     return r;
 149 }
 150
 151 /**
 152  * kvm_flic_save - Save pending floating interrupts
 153  * @f: QEMUFile containing migration state
 154  * @opaque: pointer to flic device state
 155  *
 156  * Note: Pass buf and len to kernel. Start with one page and
 157  * increase until buffer is sufficient or maxium size is
 158  * reached
 159  */
 160 static void kvm_flic_save(QEMUFile *f, void *opaque)
 161 {
 162     KVMS390FLICState *flic = opaque;
 163     int len = FLIC_SAVE_INITIAL_SIZE;
 164     void *buf;
 165     int count;
 166
 167     flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
 168
 169     buf = g_try_malloc0(len);
 170     if (!buf) {
 171         /* Storing FLIC_FAILED into the count field here will cause the
 172          * target system to fail when attempting to load irqs from the
 173          * migration state */
 174         error_report("flic: couldn't allocate memory");
 175         qemu_put_be64(f, FLIC_FAILED);
 176         return;
 177     }
 178
 179     count = __get_all_irqs(flic, &buf, len);
 180     if (count < 0) {
 181         error_report("flic: couldn't retrieve irqs from kernel, rc %d",
 182                      count);
 183         /* Storing FLIC_FAILED into the count field here will cause the
 184          * target system to fail when attempting to load irqs from the
 185          * migration state */
 186         qemu_put_be64(f, FLIC_FAILED);
 187     } else {
 188         qemu_put_be64(f, count);
 189         qemu_put_buffer(f, (uint8_t *) buf,
 190                         count * sizeof(struct kvm_s390_irq));
 191     }
 192     g_free(buf);
 193 }
 194
 195 /**
 196  * kvm_flic_load - Load pending floating interrupts
 197  * @f: QEMUFile containing migration state
 198  * @opaque: pointer to flic device state
 199  * @version_id: version id for migration
 200  *
 201  * Returns: value of flic_enqueue_irqs, -EINVAL on error
 202  * Note: Do nothing when no interrupts where stored
 203  * in QEMUFile
 204  */
 205 static int kvm_flic_load(QEMUFile *f, void *opaque, int version_id)
 206 {
 207     uint64_t len = 0;
 208     uint64_t count = 0;
 209     void *buf = NULL;
 210     int r = 0;
 211
 212     if (version_id != FLIC_SAVEVM_VERSION) {
 213         r = -EINVAL;
 214         goto out;
 215     }
 216
 217     flic_enable_pfault((struct KVMS390FLICState *) opaque);
 218
 219     count = qemu_get_be64(f);
 220     len = count * sizeof(struct kvm_s390_irq);
 221     if (count == FLIC_FAILED) {
 222         r = -EINVAL;
 223         goto out;
 224     }
 225     if (count == 0) {
 226         r = 0;
 227         goto out;
 228     }
 229     buf = g_try_malloc0(len);
 230     if (!buf) {
 231         r = -ENOMEM;
 232         goto out;
 233     }
 234
 235     if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
 236         r = -EINVAL;
 237         goto out_free;
 238     }
 239     r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
 240
 241 out_free:
 242     g_free(buf);
 243 out:
 244     return r;
 245 }
 246
 247 static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
 248 {
 249     KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
 250     struct kvm_create_device cd = {0};
 251     int ret;
 252
 253     flic_state->fd = -1;
 254     if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
 255         trace_flic_no_device_api(errno);
 256         return;
 257     }
 258
 259     cd.type = KVM_DEV_TYPE_FLIC;
 260     ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
 261     if (ret < 0) {
 262         trace_flic_create_device(errno);
 263         return;
 264     }
 265     flic_state->fd = cd.fd;
 266
 267     /* Register savevm handler for floating interrupts */
 268     register_savevm(NULL, "s390-flic", 0, 1, kvm_flic_save,
 269                     kvm_flic_load, (void *) flic_state);
 270 }
 271
 272 static void kvm_s390_flic_unrealize(DeviceState *dev, Error **errp)
 273 {
 274     KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
 275
 276     unregister_savevm(DEVICE(flic_state), "s390-flic", flic_state);
 277 }
 278
 279 static void kvm_s390_flic_reset(DeviceState *dev)
 280 {
 281     KVMS390FLICState *flic = KVM_S390_FLIC(dev);
 282     struct kvm_device_attr attr = {
 283         .group = KVM_DEV_FLIC_CLEAR_IRQS,
 284     };
 285     int rc = 0;
 286
 287     if (flic->fd == -1) {
 288         return;
 289     }
 290
 291     flic_disable_wait_pfault(flic);
 292
 293     rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
 294     if (rc) {
 295         trace_flic_reset_failed(errno);
 296     }
 297
 298     flic_enable_pfault(flic);
 299 }
 300
 301 static void kvm_s390_flic_class_init(ObjectClass *oc, void *data)
 302 {
 303     DeviceClass *dc = DEVICE_CLASS(oc);
 304
 305     dc->realize = kvm_s390_flic_realize;
 306     dc->unrealize = kvm_s390_flic_unrealize;
 307     dc->reset = kvm_s390_flic_reset;
 308 }
 309
 310 static const TypeInfo kvm_s390_flic_info = {
 311     .name          = TYPE_KVM_S390_FLIC,
 312     .parent        = TYPE_SYS_BUS_DEVICE,
 313     .instance_size = sizeof(KVMS390FLICState),
 314     .class_init    = kvm_s390_flic_class_init,
 315 };
 316
 317 static void kvm_s390_flic_register_types(void)
 318 {
 319     type_register_static(&kvm_s390_flic_info);
 320 }
 321
 322 type_init(kvm_s390_flic_register_types)