virt/kvm/arm/vgic/vgic-mmio.c

   1 /*
   2  * VGIC MMIO handling functions
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/bitops.h>
  15 #include <linux/bsearch.h>
  16 #include <linux/kvm.h>
  17 #include <linux/kvm_host.h>
  18 #include <kvm/iodev.h>
  19 #include <kvm/arm_vgic.h>
  20
  21 #include "vgic.h"
  22 #include "vgic-mmio.h"
  23
  24 unsigned long vgic_mmio_read_raz(struct kvm_vcpu *vcpu,
  25                                  gpa_t addr, unsigned int len)
  26 {
  27         return 0;
  28 }
  29
  30 unsigned long vgic_mmio_read_rao(struct kvm_vcpu *vcpu,
  31                                  gpa_t addr, unsigned int len)
  32 {
  33         return -1UL;
  34 }
  35
  36 void vgic_mmio_write_wi(struct kvm_vcpu *vcpu, gpa_t addr,
  37                         unsigned int len, unsigned long val)
  38 {
  39         /* Ignore */
  40 }
  41
  42 /*
  43  * Read accesses to both GICD_ICENABLER and GICD_ISENABLER return the value
  44  * of the enabled bit, so there is only one function for both here.
  45  */
  46 unsigned long vgic_mmio_read_enable(struct kvm_vcpu *vcpu,
  47                                     gpa_t addr, unsigned int len)
  48 {
  49         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  50         u32 value = 0;
  51         int i;
  52
  53         /* Loop over all IRQs affected by this read */
  54         for (i = 0; i < len * 8; i++) {
  55                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  56
  57                 if (irq->enabled)
  58                         value |= (1U << i);
  59         }
  60
  61         return value;
  62 }
  63
  64 void vgic_mmio_write_senable(struct kvm_vcpu *vcpu,
  65                              gpa_t addr, unsigned int len,
  66                              unsigned long val)
  67 {
  68         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  69         int i;
  70
  71         for_each_set_bit(i, &val, len * 8) {
  72                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  73
  74                 spin_lock(&irq->irq_lock);
  75                 irq->enabled = true;
  76                 vgic_queue_irq_unlock(vcpu->kvm, irq);
  77         }
  78 }
  79
  80 void vgic_mmio_write_cenable(struct kvm_vcpu *vcpu,
  81                              gpa_t addr, unsigned int len,
  82                              unsigned long val)
  83 {
  84         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  85         int i;
  86
  87         for_each_set_bit(i, &val, len * 8) {
  88                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  89
  90                 spin_lock(&irq->irq_lock);
  91
  92                 irq->enabled = false;
  93
  94                 spin_unlock(&irq->irq_lock);
  95         }
  96 }
  97
  98 unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,
  99                                      gpa_t addr, unsigned int len)
 100 {
 101         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 102         u32 value = 0;
 103         int i;
 104
 105         /* Loop over all IRQs affected by this read */
 106         for (i = 0; i < len * 8; i++) {
 107                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 108
 109                 if (irq->pending)
 110                         value |= (1U << i);
 111         }
 112
 113         return value;
 114 }
 115
 116 void vgic_mmio_write_spending(struct kvm_vcpu *vcpu,
 117                               gpa_t addr, unsigned int len,
 118                               unsigned long val)
 119 {
 120         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 121         int i;
 122
 123         for_each_set_bit(i, &val, len * 8) {
 124                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 125
 126                 spin_lock(&irq->irq_lock);
 127                 irq->pending = true;
 128                 if (irq->config == VGIC_CONFIG_LEVEL)
 129                         irq->soft_pending = true;
 130
 131                 vgic_queue_irq_unlock(vcpu->kvm, irq);
 132         }
 133 }
 134
 135 void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu,
 136                               gpa_t addr, unsigned int len,
 137                               unsigned long val)
 138 {
 139         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 140         int i;
 141
 142         for_each_set_bit(i, &val, len * 8) {
 143                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 144
 145                 spin_lock(&irq->irq_lock);
 146
 147                 if (irq->config == VGIC_CONFIG_LEVEL) {
 148                         irq->soft_pending = false;
 149                         irq->pending = irq->line_level;
 150                 } else {
 151                         irq->pending = false;
 152                 }
 153
 154                 spin_unlock(&irq->irq_lock);
 155         }
 156 }
 157
 158 unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,
 159                                     gpa_t addr, unsigned int len)
 160 {
 161         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 162         u32 value = 0;
 163         int i;
 164
 165         /* Loop over all IRQs affected by this read */
 166         for (i = 0; i < len * 8; i++) {
 167                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 168
 169                 if (irq->active)
 170                         value |= (1U << i);
 171         }
 172
 173         return value;
 174 }
 175
 176 void vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,
 177                              gpa_t addr, unsigned int len,
 178                              unsigned long val)
 179 {
 180         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 181         int i;
 182
 183         kvm_arm_halt_guest(vcpu->kvm);
 184         for_each_set_bit(i, &val, len * 8) {
 185                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 186
 187                 spin_lock(&irq->irq_lock);
 188                 /*
 189                  * If this virtual IRQ was written into a list register, we
 190                  * have to make sure the CPU that runs the VCPU thread has
 191                  * synced back LR state to the struct vgic_irq.  We can only
 192                  * know this for sure, when either this irq is not assigned to
 193                  * anyone's AP list anymore, or the VCPU thread is not
 194                  * running on any CPUs.
 195                  *
 196                  * In the opposite case, we know the VCPU thread may be on its
 197                  * way back from the guest and still has to sync back this
 198                  * IRQ, so we release and re-acquire the spin_lock to let the
 199                  * other thread sync back the IRQ.
 200                  */
 201                 while (irq->vcpu && /* IRQ may have state in an LR somewhere */
 202                        irq->vcpu->cpu != -1) /* VCPU thread is running */
 203                         cond_resched_lock(&irq->irq_lock);
 204
 205                 irq->active = false;
 206                 spin_unlock(&irq->irq_lock);
 207         }
 208         kvm_arm_resume_guest(vcpu->kvm);
 209 }
 210
 211 void vgic_mmio_write_sactive(struct kvm_vcpu *vcpu,
 212                              gpa_t addr, unsigned int len,
 213                              unsigned long val)
 214 {
 215         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 216         int i;
 217
 218         for_each_set_bit(i, &val, len * 8) {
 219                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 220
 221                 spin_lock(&irq->irq_lock);
 222
 223                 /*
 224                  * If the IRQ was already active or there is no target VCPU
 225                  * assigned at the moment, then just proceed.
 226                  */
 227                 if (irq->active || !irq->target_vcpu) {
 228                         irq->active = true;
 229
 230                         spin_unlock(&irq->irq_lock);
 231                         continue;
 232                 }
 233
 234                 irq->active = true;
 235                 vgic_queue_irq_unlock(vcpu->kvm, irq);
 236         }
 237 }
 238
 239 unsigned long vgic_mmio_read_priority(struct kvm_vcpu *vcpu,
 240                                       gpa_t addr, unsigned int len)
 241 {
 242         u32 intid = VGIC_ADDR_TO_INTID(addr, 8);
 243         int i;
 244         u64 val = 0;
 245
 246         for (i = 0; i < len; i++) {
 247                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 248
 249                 val |= (u64)irq->priority << (i * 8);
 250         }
 251
 252         return val;
 253 }
 254
 255 /*
 256  * We currently don't handle changing the priority of an interrupt that
 257  * is already pending on a VCPU. If there is a need for this, we would
 258  * need to make this VCPU exit and re-evaluate the priorities, potentially
 259  * leading to this interrupt getting presented now to the guest (if it has
 260  * been masked by the priority mask before).
 261  */
 262 void vgic_mmio_write_priority(struct kvm_vcpu *vcpu,
 263                               gpa_t addr, unsigned int len,
 264                               unsigned long val)
 265 {
 266         u32 intid = VGIC_ADDR_TO_INTID(addr, 8);
 267         int i;
 268
 269         for (i = 0; i < len; i++) {
 270                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 271
 272                 spin_lock(&irq->irq_lock);
 273                 /* Narrow the priority range to what we actually support */
 274                 irq->priority = (val >> (i * 8)) & GENMASK(7, 8 - VGIC_PRI_BITS);
 275                 spin_unlock(&irq->irq_lock);
 276         }
 277 }
 278
 279 static int match_region(const void *key, const void *elt)
 280 {
 281         const unsigned int offset = (unsigned long)key;
 282         const struct vgic_register_region *region = elt;
 283
 284         if (offset < region->reg_offset)
 285                 return -1;
 286
 287         if (offset >= region->reg_offset + region->len)
 288                 return 1;
 289
 290         return 0;
 291 }
 292
 293 /* Find the proper register handler entry given a certain address offset. */
 294 static const struct vgic_register_region *
 295 vgic_find_mmio_region(const struct vgic_register_region *region, int nr_regions,
 296                       unsigned int offset)
 297 {
 298         return bsearch((void *)(uintptr_t)offset, region, nr_regions,
 299                        sizeof(region[0]), match_region);
 300 }
 301
 302 /*
 303  * kvm_mmio_read_buf() returns a value in a format where it can be converted
 304  * to a byte array and be directly observed as the guest wanted it to appear
 305  * in memory if it had done the store itself, which is LE for the GIC, as the
 306  * guest knows the GIC is always LE.
 307  *
 308  * We convert this value to the CPUs native format to deal with it as a data
 309  * value.
 310  */
 311 unsigned long vgic_data_mmio_bus_to_host(const void *val, unsigned int len)
 312 {
 313         unsigned long data = kvm_mmio_read_buf(val, len);
 314
 315         switch (len) {
 316         case 1:
 317                 return data;
 318         case 2:
 319                 return le16_to_cpu(data);
 320         case 4:
 321                 return le32_to_cpu(data);
 322         default:
 323                 return le64_to_cpu(data);
 324         }
 325 }
 326
 327 /*
 328  * kvm_mmio_write_buf() expects a value in a format such that if converted to
 329  * a byte array it is observed as the guest would see it if it could perform
 330  * the load directly.  Since the GIC is LE, and the guest knows this, the
 331  * guest expects a value in little endian format.
 332  *
 333  * We convert the data value from the CPUs native format to LE so that the
 334  * value is returned in the proper format.
 335  */
 336 void vgic_data_host_to_mmio_bus(void *buf, unsigned int len,
 337                                 unsigned long data)
 338 {
 339         switch (len) {
 340         case 1:
 341                 break;
 342         case 2:
 343                 data = cpu_to_le16(data);
 344                 break;
 345         case 4:
 346                 data = cpu_to_le32(data);
 347                 break;
 348         default:
 349                 data = cpu_to_le64(data);
 350         }
 351
 352         kvm_mmio_write_buf(buf, len, data);
 353 }
 354
 355 static
 356 struct vgic_io_device *kvm_to_vgic_iodev(const struct kvm_io_device *dev)
 357 {
 358         return container_of(dev, struct vgic_io_device, dev);
 359 }
 360
 361 static bool check_region(const struct vgic_register_region *region,
 362                          gpa_t addr, int len)
 363 {
 364         if ((region->access_flags & VGIC_ACCESS_8bit) && len == 1)
 365                 return true;
 366         if ((region->access_flags & VGIC_ACCESS_32bit) &&
 367             len == sizeof(u32) && !(addr & 3))
 368                 return true;
 369         if ((region->access_flags & VGIC_ACCESS_64bit) &&
 370             len == sizeof(u64) && !(addr & 7))
 371                 return true;
 372
 373         return false;
 374 }
 375
 376 static int dispatch_mmio_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 377                               gpa_t addr, int len, void *val)
 378 {
 379         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 380         const struct vgic_register_region *region;
 381         struct kvm_vcpu *r_vcpu;
 382         unsigned long data;
 383
 384         region = vgic_find_mmio_region(iodev->regions, iodev->nr_regions,
 385                                        addr - iodev->base_addr);
 386         if (!region || !check_region(region, addr, len)) {
 387                 memset(val, 0, len);
 388                 return 0;
 389         }
 390
 391         r_vcpu = iodev->redist_vcpu ? iodev->redist_vcpu : vcpu;
 392         data = region->read(r_vcpu, addr, len);
 393         vgic_data_host_to_mmio_bus(val, len, data);
 394         return 0;
 395 }
 396
 397 static int dispatch_mmio_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 398                                gpa_t addr, int len, const void *val)
 399 {
 400         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 401         const struct vgic_register_region *region;
 402         struct kvm_vcpu *r_vcpu;
 403         unsigned long data = vgic_data_mmio_bus_to_host(val, len);
 404
 405         region = vgic_find_mmio_region(iodev->regions, iodev->nr_regions,
 406                                        addr - iodev->base_addr);
 407         if (!region)
 408                 return 0;
 409
 410         if (!check_region(region, addr, len))
 411                 return 0;
 412
 413         r_vcpu = iodev->redist_vcpu ? iodev->redist_vcpu : vcpu;
 414         region->write(r_vcpu, addr, len, data);
 415         return 0;
 416 }
 417
 418 struct kvm_io_device_ops kvm_io_gic_ops = {
 419         .read = dispatch_mmio_read,
 420         .write = dispatch_mmio_write,
 421 };
 422
 423 int vgic_register_dist_iodev(struct kvm *kvm, gpa_t dist_base_address,
 424                              enum vgic_type type)
 425 {
 426         struct vgic_io_device *io_device = &kvm->arch.vgic.dist_iodev;
 427         int ret = 0;
 428         unsigned int len;
 429
 430         switch (type) {
 431         case VGIC_V2:
 432                 len = vgic_v2_init_dist_iodev(io_device);
 433                 break;
 434         default:
 435                 BUG_ON(1);
 436         }
 437
 438         io_device->base_addr = dist_base_address;
 439         io_device->redist_vcpu = NULL;
 440
 441         mutex_lock(&kvm->slots_lock);
 442         ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, dist_base_address,
 443                                       len, &io_device->dev);
 444         mutex_unlock(&kvm->slots_lock);
 445
 446         return ret;
 447 }