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

   1 /*
   2  * VGIC: KVM DEVICE API
   3  *
   4  * Copyright (C) 2015 ARM Ltd.
   5  * Author: Marc Zyngier <marc.zyngier@arm.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16 #include <linux/kvm_host.h>
  17 #include <kvm/arm_vgic.h>
  18 #include <linux/uaccess.h>
  19 #include <asm/kvm_mmu.h>
  20 #include "vgic.h"
  21
  22 /* common helpers */
  23
  24 int vgic_check_ioaddr(struct kvm *kvm, phys_addr_t *ioaddr,
  25                       phys_addr_t addr, phys_addr_t alignment)
  26 {
  27         if (addr & ~KVM_PHYS_MASK)
  28                 return -E2BIG;
  29
  30         if (!IS_ALIGNED(addr, alignment))
  31                 return -EINVAL;
  32
  33         if (!IS_VGIC_ADDR_UNDEF(*ioaddr))
  34                 return -EEXIST;
  35
  36         return 0;
  37 }
  38
  39 /**
  40  * kvm_vgic_addr - set or get vgic VM base addresses
  41  * @kvm:   pointer to the vm struct
  42  * @type:  the VGIC addr type, one of KVM_VGIC_V[23]_ADDR_TYPE_XXX
  43  * @addr:  pointer to address value
  44  * @write: if true set the address in the VM address space, if false read the
  45  *          address
  46  *
  47  * Set or get the vgic base addresses for the distributor and the virtual CPU
  48  * interface in the VM physical address space.  These addresses are properties
  49  * of the emulated core/SoC and therefore user space initially knows this
  50  * information.
  51  * Check them for sanity (alignment, double assignment). We can't check for
  52  * overlapping regions in case of a virtual GICv3 here, since we don't know
  53  * the number of VCPUs yet, so we defer this check to map_resources().
  54  */
  55 int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write)
  56 {
  57         int r = 0;
  58         struct vgic_dist *vgic = &kvm->arch.vgic;
  59         int type_needed;
  60         phys_addr_t *addr_ptr, alignment;
  61
  62         mutex_lock(&kvm->lock);
  63         switch (type) {
  64         case KVM_VGIC_V2_ADDR_TYPE_DIST:
  65                 type_needed = KVM_DEV_TYPE_ARM_VGIC_V2;
  66                 addr_ptr = &vgic->vgic_dist_base;
  67                 alignment = SZ_4K;
  68                 break;
  69         case KVM_VGIC_V2_ADDR_TYPE_CPU:
  70                 type_needed = KVM_DEV_TYPE_ARM_VGIC_V2;
  71                 addr_ptr = &vgic->vgic_cpu_base;
  72                 alignment = SZ_4K;
  73                 break;
  74         case KVM_VGIC_V3_ADDR_TYPE_DIST:
  75                 type_needed = KVM_DEV_TYPE_ARM_VGIC_V3;
  76                 addr_ptr = &vgic->vgic_dist_base;
  77                 alignment = SZ_64K;
  78                 break;
  79         case KVM_VGIC_V3_ADDR_TYPE_REDIST:
  80                 type_needed = KVM_DEV_TYPE_ARM_VGIC_V3;
  81                 addr_ptr = &vgic->vgic_redist_base;
  82                 alignment = SZ_64K;
  83                 break;
  84         default:
  85                 r = -ENODEV;
  86                 goto out;
  87         }
  88
  89         if (vgic->vgic_model != type_needed) {
  90                 r = -ENODEV;
  91                 goto out;
  92         }
  93
  94         if (write) {
  95                 r = vgic_check_ioaddr(kvm, addr_ptr, *addr, alignment);
  96                 if (!r)
  97                         *addr_ptr = *addr;
  98         } else {
  99                 *addr = *addr_ptr;
 100         }
 101
 102 out:
 103         mutex_unlock(&kvm->lock);
 104         return r;
 105 }
 106
 107 static int vgic_set_common_attr(struct kvm_device *dev,
 108                                 struct kvm_device_attr *attr)
 109 {
 110         int r;
 111
 112         switch (attr->group) {
 113         case KVM_DEV_ARM_VGIC_GRP_ADDR: {
 114                 u64 __user *uaddr = (u64 __user *)(long)attr->addr;
 115                 u64 addr;
 116                 unsigned long type = (unsigned long)attr->attr;
 117
 118                 if (copy_from_user(&addr, uaddr, sizeof(addr)))
 119                         return -EFAULT;
 120
 121                 r = kvm_vgic_addr(dev->kvm, type, &addr, true);
 122                 return (r == -ENODEV) ? -ENXIO : r;
 123         }
 124         case KVM_DEV_ARM_VGIC_GRP_NR_IRQS: {
 125                 u32 __user *uaddr = (u32 __user *)(long)attr->addr;
 126                 u32 val;
 127                 int ret = 0;
 128
 129                 if (get_user(val, uaddr))
 130                         return -EFAULT;
 131
 132                 /*
 133                  * We require:
 134                  * - at least 32 SPIs on top of the 16 SGIs and 16 PPIs
 135                  * - at most 1024 interrupts
 136                  * - a multiple of 32 interrupts
 137                  */
 138                 if (val < (VGIC_NR_PRIVATE_IRQS + 32) ||
 139                     val > VGIC_MAX_RESERVED ||
 140                     (val & 31))
 141                         return -EINVAL;
 142
 143                 mutex_lock(&dev->kvm->lock);
 144
 145                 if (vgic_ready(dev->kvm) || dev->kvm->arch.vgic.nr_spis)
 146                         ret = -EBUSY;
 147                 else
 148                         dev->kvm->arch.vgic.nr_spis =
 149                                 val - VGIC_NR_PRIVATE_IRQS;
 150
 151                 mutex_unlock(&dev->kvm->lock);
 152
 153                 return ret;
 154         }
 155         case KVM_DEV_ARM_VGIC_GRP_CTRL: {
 156                 switch (attr->attr) {
 157                 case KVM_DEV_ARM_VGIC_CTRL_INIT:
 158                         mutex_lock(&dev->kvm->lock);
 159                         r = vgic_init(dev->kvm);
 160                         mutex_unlock(&dev->kvm->lock);
 161                         return r;
 162                 }
 163                 break;
 164         }
 165         }
 166
 167         return -ENXIO;
 168 }
 169
 170 static int vgic_get_common_attr(struct kvm_device *dev,
 171                                 struct kvm_device_attr *attr)
 172 {
 173         int r = -ENXIO;
 174
 175         switch (attr->group) {
 176         case KVM_DEV_ARM_VGIC_GRP_ADDR: {
 177                 u64 __user *uaddr = (u64 __user *)(long)attr->addr;
 178                 u64 addr;
 179                 unsigned long type = (unsigned long)attr->attr;
 180
 181                 r = kvm_vgic_addr(dev->kvm, type, &addr, false);
 182                 if (r)
 183                         return (r == -ENODEV) ? -ENXIO : r;
 184
 185                 if (copy_to_user(uaddr, &addr, sizeof(addr)))
 186                         return -EFAULT;
 187                 break;
 188         }
 189         case KVM_DEV_ARM_VGIC_GRP_NR_IRQS: {
 190                 u32 __user *uaddr = (u32 __user *)(long)attr->addr;
 191
 192                 r = put_user(dev->kvm->arch.vgic.nr_spis +
 193                              VGIC_NR_PRIVATE_IRQS, uaddr);
 194                 break;
 195         }
 196         }
 197
 198         return r;
 199 }
 200
 201 static int vgic_create(struct kvm_device *dev, u32 type)
 202 {
 203         return kvm_vgic_create(dev->kvm, type);
 204 }
 205
 206 static void vgic_destroy(struct kvm_device *dev)
 207 {
 208         kfree(dev);
 209 }
 210
 211 int kvm_register_vgic_device(unsigned long type)
 212 {
 213         int ret = -ENODEV;
 214
 215         switch (type) {
 216         case KVM_DEV_TYPE_ARM_VGIC_V2:
 217                 ret = kvm_register_device_ops(&kvm_arm_vgic_v2_ops,
 218                                               KVM_DEV_TYPE_ARM_VGIC_V2);
 219                 break;
 220         case KVM_DEV_TYPE_ARM_VGIC_V3:
 221                 ret = kvm_register_device_ops(&kvm_arm_vgic_v3_ops,
 222                                               KVM_DEV_TYPE_ARM_VGIC_V3);
 223
 224 #ifdef CONFIG_KVM_ARM_VGIC_V3_ITS
 225                 if (ret)
 226                         break;
 227                 ret = kvm_vgic_register_its_device();
 228 #endif
 229                 break;
 230         }
 231
 232         return ret;
 233 }
 234
 235 struct vgic_reg_attr {
 236         struct kvm_vcpu *vcpu;
 237         gpa_t addr;
 238 };
 239
 240 static int parse_vgic_v2_attr(struct kvm_device *dev,
 241                               struct kvm_device_attr *attr,
 242                               struct vgic_reg_attr *reg_attr)
 243 {
 244         int cpuid;
 245
 246         cpuid = (attr->attr & KVM_DEV_ARM_VGIC_CPUID_MASK) >>
 247                  KVM_DEV_ARM_VGIC_CPUID_SHIFT;
 248
 249         if (cpuid >= atomic_read(&dev->kvm->online_vcpus))
 250                 return -EINVAL;
 251
 252         reg_attr->vcpu = kvm_get_vcpu(dev->kvm, cpuid);
 253         reg_attr->addr = attr->attr & KVM_DEV_ARM_VGIC_OFFSET_MASK;
 254
 255         return 0;
 256 }
 257
 258 /* unlocks vcpus from @vcpu_lock_idx and smaller */
 259 static void unlock_vcpus(struct kvm *kvm, int vcpu_lock_idx)
 260 {
 261         struct kvm_vcpu *tmp_vcpu;
 262
 263         for (; vcpu_lock_idx >= 0; vcpu_lock_idx--) {
 264                 tmp_vcpu = kvm_get_vcpu(kvm, vcpu_lock_idx);
 265                 mutex_unlock(&tmp_vcpu->mutex);
 266         }
 267 }
 268
 269 static void unlock_all_vcpus(struct kvm *kvm)
 270 {
 271         unlock_vcpus(kvm, atomic_read(&kvm->online_vcpus) - 1);
 272 }
 273
 274 /* Returns true if all vcpus were locked, false otherwise */
 275 static bool lock_all_vcpus(struct kvm *kvm)
 276 {
 277         struct kvm_vcpu *tmp_vcpu;
 278         int c;
 279
 280         /*
 281          * Any time a vcpu is run, vcpu_load is called which tries to grab the
 282          * vcpu->mutex.  By grabbing the vcpu->mutex of all VCPUs we ensure
 283          * that no other VCPUs are run and fiddle with the vgic state while we
 284          * access it.
 285          */
 286         kvm_for_each_vcpu(c, tmp_vcpu, kvm) {
 287                 if (!mutex_trylock(&tmp_vcpu->mutex)) {
 288                         unlock_vcpus(kvm, c - 1);
 289                         return false;
 290                 }
 291         }
 292
 293         return true;
 294 }
 295
 296 /**
 297  * vgic_attr_regs_access_v2 - allows user space to access VGIC v2 state
 298  *
 299  * @dev:      kvm device handle
 300  * @attr:     kvm device attribute
 301  * @reg:      address the value is read or written
 302  * @is_write: true if userspace is writing a register
 303  */
 304 static int vgic_attr_regs_access_v2(struct kvm_device *dev,
 305                                     struct kvm_device_attr *attr,
 306                                     u32 *reg, bool is_write)
 307 {
 308         struct vgic_reg_attr reg_attr;
 309         gpa_t addr;
 310         struct kvm_vcpu *vcpu;
 311         int ret;
 312
 313         ret = parse_vgic_v2_attr(dev, attr, &reg_attr);
 314         if (ret)
 315                 return ret;
 316
 317         vcpu = reg_attr.vcpu;
 318         addr = reg_attr.addr;
 319
 320         mutex_lock(&dev->kvm->lock);
 321
 322         ret = vgic_init(dev->kvm);
 323         if (ret)
 324                 goto out;
 325
 326         if (!lock_all_vcpus(dev->kvm)) {
 327                 ret = -EBUSY;
 328                 goto out;
 329         }
 330
 331         switch (attr->group) {
 332         case KVM_DEV_ARM_VGIC_GRP_CPU_REGS:
 333                 ret = vgic_v2_cpuif_uaccess(vcpu, is_write, addr, reg);
 334                 break;
 335         case KVM_DEV_ARM_VGIC_GRP_DIST_REGS:
 336                 ret = vgic_v2_dist_uaccess(vcpu, is_write, addr, reg);
 337                 break;
 338         default:
 339                 ret = -EINVAL;
 340                 break;
 341         }
 342
 343         unlock_all_vcpus(dev->kvm);
 344 out:
 345         mutex_unlock(&dev->kvm->lock);
 346         return ret;
 347 }
 348
 349 static int vgic_v2_set_attr(struct kvm_device *dev,
 350                             struct kvm_device_attr *attr)
 351 {
 352         int ret;
 353
 354         ret = vgic_set_common_attr(dev, attr);
 355         if (ret != -ENXIO)
 356                 return ret;
 357
 358         switch (attr->group) {
 359         case KVM_DEV_ARM_VGIC_GRP_DIST_REGS:
 360         case KVM_DEV_ARM_VGIC_GRP_CPU_REGS: {
 361                 u32 __user *uaddr = (u32 __user *)(long)attr->addr;
 362                 u32 reg;
 363
 364                 if (get_user(reg, uaddr))
 365                         return -EFAULT;
 366
 367                 return vgic_attr_regs_access_v2(dev, attr, &reg, true);
 368         }
 369         }
 370
 371         return -ENXIO;
 372 }
 373
 374 static int vgic_v2_get_attr(struct kvm_device *dev,
 375                             struct kvm_device_attr *attr)
 376 {
 377         int ret;
 378
 379         ret = vgic_get_common_attr(dev, attr);
 380         if (ret != -ENXIO)
 381                 return ret;
 382
 383         switch (attr->group) {
 384         case KVM_DEV_ARM_VGIC_GRP_DIST_REGS:
 385         case KVM_DEV_ARM_VGIC_GRP_CPU_REGS: {
 386                 u32 __user *uaddr = (u32 __user *)(long)attr->addr;
 387                 u32 reg = 0;
 388
 389                 ret = vgic_attr_regs_access_v2(dev, attr, &reg, false);
 390                 if (ret)
 391                         return ret;
 392                 return put_user(reg, uaddr);
 393         }
 394         }
 395
 396         return -ENXIO;
 397 }
 398
 399 static int vgic_v2_has_attr(struct kvm_device *dev,
 400                             struct kvm_device_attr *attr)
 401 {
 402         switch (attr->group) {
 403         case KVM_DEV_ARM_VGIC_GRP_ADDR:
 404                 switch (attr->attr) {
 405                 case KVM_VGIC_V2_ADDR_TYPE_DIST:
 406                 case KVM_VGIC_V2_ADDR_TYPE_CPU:
 407                         return 0;
 408                 }
 409                 break;
 410         case KVM_DEV_ARM_VGIC_GRP_DIST_REGS:
 411         case KVM_DEV_ARM_VGIC_GRP_CPU_REGS:
 412                 return vgic_v2_has_attr_regs(dev, attr);
 413         case KVM_DEV_ARM_VGIC_GRP_NR_IRQS:
 414                 return 0;
 415         case KVM_DEV_ARM_VGIC_GRP_CTRL:
 416                 switch (attr->attr) {
 417                 case KVM_DEV_ARM_VGIC_CTRL_INIT:
 418                         return 0;
 419                 }
 420         }
 421         return -ENXIO;
 422 }
 423
 424 struct kvm_device_ops kvm_arm_vgic_v2_ops = {
 425         .name = "kvm-arm-vgic-v2",
 426         .create = vgic_create,
 427         .destroy = vgic_destroy,
 428         .set_attr = vgic_v2_set_attr,
 429         .get_attr = vgic_v2_get_attr,
 430         .has_attr = vgic_v2_has_attr,
 431 };
 432
 433 static int vgic_v3_set_attr(struct kvm_device *dev,
 434                             struct kvm_device_attr *attr)
 435 {
 436         return vgic_set_common_attr(dev, attr);
 437 }
 438
 439 static int vgic_v3_get_attr(struct kvm_device *dev,
 440                             struct kvm_device_attr *attr)
 441 {
 442         return vgic_get_common_attr(dev, attr);
 443 }
 444
 445 static int vgic_v3_has_attr(struct kvm_device *dev,
 446                             struct kvm_device_attr *attr)
 447 {
 448         switch (attr->group) {
 449         case KVM_DEV_ARM_VGIC_GRP_ADDR:
 450                 switch (attr->attr) {
 451                 case KVM_VGIC_V3_ADDR_TYPE_DIST:
 452                 case KVM_VGIC_V3_ADDR_TYPE_REDIST:
 453                         return 0;
 454                 }
 455                 break;
 456         case KVM_DEV_ARM_VGIC_GRP_NR_IRQS:
 457                 return 0;
 458         case KVM_DEV_ARM_VGIC_GRP_CTRL:
 459                 switch (attr->attr) {
 460                 case KVM_DEV_ARM_VGIC_CTRL_INIT:
 461                         return 0;
 462                 }
 463         }
 464         return -ENXIO;
 465 }
 466
 467 struct kvm_device_ops kvm_arm_vgic_v3_ops = {
 468         .name = "kvm-arm-vgic-v3",
 469         .create = vgic_create,
 470         .destroy = vgic_destroy,
 471         .set_attr = vgic_v3_set_attr,
 472         .get_attr = vgic_v3_get_attr,
 473         .has_attr = vgic_v3_has_attr,
 474 };