arch/arm64/kvm/guest.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012,2013 - ARM Ltd
   4  * Author: Marc Zyngier <marc.zyngier@arm.com>
   5  *
   6  * Derived from arch/arm/kvm/guest.c:
   7  * Copyright (C) 2012 - Virtual Open Systems and Columbia University
   8  * Author: Christoffer Dall <c.dall@virtualopensystems.com>
   9  */
  10
  11 #include <linux/bits.h>
  12 #include <linux/errno.h>
  13 #include <linux/err.h>
  14 #include <linux/nospec.h>
  15 #include <linux/kvm_host.h>
  16 #include <linux/module.h>
  17 #include <linux/stddef.h>
  18 #include <linux/string.h>
  19 #include <linux/vmalloc.h>
  20 #include <linux/fs.h>
  21 #include <kvm/arm_psci.h>
  22 #include <asm/cputype.h>
  23 #include <linux/uaccess.h>
  24 #include <asm/fpsimd.h>
  25 #include <asm/kvm.h>
  26 #include <asm/kvm_emulate.h>
  27 #include <asm/sigcontext.h>
  28
  29 #include "trace.h"
  30
  31 struct kvm_stats_debugfs_item debugfs_entries[] = {
  32         VCPU_STAT("halt_successful_poll", halt_successful_poll),
  33         VCPU_STAT("halt_attempted_poll", halt_attempted_poll),
  34         VCPU_STAT("halt_poll_invalid", halt_poll_invalid),
  35         VCPU_STAT("halt_wakeup", halt_wakeup),
  36         VCPU_STAT("hvc_exit_stat", hvc_exit_stat),
  37         VCPU_STAT("wfe_exit_stat", wfe_exit_stat),
  38         VCPU_STAT("wfi_exit_stat", wfi_exit_stat),
  39         VCPU_STAT("mmio_exit_user", mmio_exit_user),
  40         VCPU_STAT("mmio_exit_kernel", mmio_exit_kernel),
  41         VCPU_STAT("exits", exits),
  42         VCPU_STAT("halt_poll_success_ns", halt_poll_success_ns),
  43         VCPU_STAT("halt_poll_fail_ns", halt_poll_fail_ns),
  44         { NULL }
  45 };
  46
  47 static bool core_reg_offset_is_vreg(u64 off)
  48 {
  49         return off >= KVM_REG_ARM_CORE_REG(fp_regs.vregs) &&
  50                 off < KVM_REG_ARM_CORE_REG(fp_regs.fpsr);
  51 }
  52
  53 static u64 core_reg_offset_from_id(u64 id)
  54 {
  55         return id & ~(KVM_REG_ARCH_MASK | KVM_REG_SIZE_MASK | KVM_REG_ARM_CORE);
  56 }
  57
  58 static int core_reg_size_from_offset(const struct kvm_vcpu *vcpu, u64 off)
  59 {
  60         int size;
  61
  62         switch (off) {
  63         case KVM_REG_ARM_CORE_REG(regs.regs[0]) ...
  64              KVM_REG_ARM_CORE_REG(regs.regs[30]):
  65         case KVM_REG_ARM_CORE_REG(regs.sp):
  66         case KVM_REG_ARM_CORE_REG(regs.pc):
  67         case KVM_REG_ARM_CORE_REG(regs.pstate):
  68         case KVM_REG_ARM_CORE_REG(sp_el1):
  69         case KVM_REG_ARM_CORE_REG(elr_el1):
  70         case KVM_REG_ARM_CORE_REG(spsr[0]) ...
  71              KVM_REG_ARM_CORE_REG(spsr[KVM_NR_SPSR - 1]):
  72                 size = sizeof(__u64);
  73                 break;
  74
  75         case KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]) ...
  76              KVM_REG_ARM_CORE_REG(fp_regs.vregs[31]):
  77                 size = sizeof(__uint128_t);
  78                 break;
  79
  80         case KVM_REG_ARM_CORE_REG(fp_regs.fpsr):
  81         case KVM_REG_ARM_CORE_REG(fp_regs.fpcr):
  82                 size = sizeof(__u32);
  83                 break;
  84
  85         default:
  86                 return -EINVAL;
  87         }
  88
  89         if (!IS_ALIGNED(off, size / sizeof(__u32)))
  90                 return -EINVAL;
  91
  92         /*
  93          * The KVM_REG_ARM64_SVE regs must be used instead of
  94          * KVM_REG_ARM_CORE for accessing the FPSIMD V-registers on
  95          * SVE-enabled vcpus:
  96          */
  97         if (vcpu_has_sve(vcpu) && core_reg_offset_is_vreg(off))
  98                 return -EINVAL;
  99
 100         return size;
 101 }
 102
 103 static void *core_reg_addr(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 104 {
 105         u64 off = core_reg_offset_from_id(reg->id);
 106         int size = core_reg_size_from_offset(vcpu, off);
 107
 108         if (size < 0)
 109                 return NULL;
 110
 111         if (KVM_REG_SIZE(reg->id) != size)
 112                 return NULL;
 113
 114         switch (off) {
 115         case KVM_REG_ARM_CORE_REG(regs.regs[0]) ...
 116              KVM_REG_ARM_CORE_REG(regs.regs[30]):
 117                 off -= KVM_REG_ARM_CORE_REG(regs.regs[0]);
 118                 off /= 2;
 119                 return &vcpu->arch.ctxt.regs.regs[off];
 120
 121         case KVM_REG_ARM_CORE_REG(regs.sp):
 122                 return &vcpu->arch.ctxt.regs.sp;
 123
 124         case KVM_REG_ARM_CORE_REG(regs.pc):
 125                 return &vcpu->arch.ctxt.regs.pc;
 126
 127         case KVM_REG_ARM_CORE_REG(regs.pstate):
 128                 return &vcpu->arch.ctxt.regs.pstate;
 129
 130         case KVM_REG_ARM_CORE_REG(sp_el1):
 131                 return __ctxt_sys_reg(&vcpu->arch.ctxt, SP_EL1);
 132
 133         case KVM_REG_ARM_CORE_REG(elr_el1):
 134                 return __ctxt_sys_reg(&vcpu->arch.ctxt, ELR_EL1);
 135
 136         case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_EL1]):
 137                 return __ctxt_sys_reg(&vcpu->arch.ctxt, SPSR_EL1);
 138
 139         case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_ABT]):
 140                 return &vcpu->arch.ctxt.spsr_abt;
 141
 142         case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_UND]):
 143                 return &vcpu->arch.ctxt.spsr_und;
 144
 145         case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_IRQ]):
 146                 return &vcpu->arch.ctxt.spsr_irq;
 147
 148         case KVM_REG_ARM_CORE_REG(spsr[KVM_SPSR_FIQ]):
 149                 return &vcpu->arch.ctxt.spsr_fiq;
 150
 151         case KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]) ...
 152              KVM_REG_ARM_CORE_REG(fp_regs.vregs[31]):
 153                 off -= KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]);
 154                 off /= 4;
 155                 return &vcpu->arch.ctxt.fp_regs.vregs[off];
 156
 157         case KVM_REG_ARM_CORE_REG(fp_regs.fpsr):
 158                 return &vcpu->arch.ctxt.fp_regs.fpsr;
 159
 160         case KVM_REG_ARM_CORE_REG(fp_regs.fpcr):
 161                 return &vcpu->arch.ctxt.fp_regs.fpcr;
 162
 163         default:
 164                 return NULL;
 165         }
 166 }
 167
 168 static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 169 {
 170         /*
 171          * Because the kvm_regs structure is a mix of 32, 64 and
 172          * 128bit fields, we index it as if it was a 32bit
 173          * array. Hence below, nr_regs is the number of entries, and
 174          * off the index in the "array".
 175          */
 176         __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
 177         int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);
 178         void *addr;
 179         u32 off;
 180
 181         /* Our ID is an index into the kvm_regs struct. */
 182         off = core_reg_offset_from_id(reg->id);
 183         if (off >= nr_regs ||
 184             (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
 185                 return -ENOENT;
 186
 187         addr = core_reg_addr(vcpu, reg);
 188         if (!addr)
 189                 return -EINVAL;
 190
 191         if (copy_to_user(uaddr, addr, KVM_REG_SIZE(reg->id)))
 192                 return -EFAULT;
 193
 194         return 0;
 195 }
 196
 197 static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 198 {
 199         __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
 200         int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);
 201         __uint128_t tmp;
 202         void *valp = &tmp, *addr;
 203         u64 off;
 204         int err = 0;
 205
 206         /* Our ID is an index into the kvm_regs struct. */
 207         off = core_reg_offset_from_id(reg->id);
 208         if (off >= nr_regs ||
 209             (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
 210                 return -ENOENT;
 211
 212         addr = core_reg_addr(vcpu, reg);
 213         if (!addr)
 214                 return -EINVAL;
 215
 216         if (KVM_REG_SIZE(reg->id) > sizeof(tmp))
 217                 return -EINVAL;
 218
 219         if (copy_from_user(valp, uaddr, KVM_REG_SIZE(reg->id))) {
 220                 err = -EFAULT;
 221                 goto out;
 222         }
 223
 224         if (off == KVM_REG_ARM_CORE_REG(regs.pstate)) {
 225                 u64 mode = (*(u64 *)valp) & PSR_AA32_MODE_MASK;
 226                 switch (mode) {
 227                 case PSR_AA32_MODE_USR:
 228                         if (!system_supports_32bit_el0())
 229                                 return -EINVAL;
 230                         break;
 231                 case PSR_AA32_MODE_FIQ:
 232                 case PSR_AA32_MODE_IRQ:
 233                 case PSR_AA32_MODE_SVC:
 234                 case PSR_AA32_MODE_ABT:
 235                 case PSR_AA32_MODE_UND:
 236                         if (!vcpu_el1_is_32bit(vcpu))
 237                                 return -EINVAL;
 238                         break;
 239                 case PSR_MODE_EL0t:
 240                 case PSR_MODE_EL1t:
 241                 case PSR_MODE_EL1h:
 242                         if (vcpu_el1_is_32bit(vcpu))
 243                                 return -EINVAL;
 244                         break;
 245                 default:
 246                         err = -EINVAL;
 247                         goto out;
 248                 }
 249         }
 250
 251         memcpy(addr, valp, KVM_REG_SIZE(reg->id));
 252
 253         if (*vcpu_cpsr(vcpu) & PSR_MODE32_BIT) {
 254                 int i, nr_reg;
 255
 256                 switch (*vcpu_cpsr(vcpu)) {
 257                 /*
 258                  * Either we are dealing with user mode, and only the
 259                  * first 15 registers (+ PC) must be narrowed to 32bit.
 260                  * AArch32 r0-r14 conveniently map to AArch64 x0-x14.
 261                  */
 262                 case PSR_AA32_MODE_USR:
 263                 case PSR_AA32_MODE_SYS:
 264                         nr_reg = 15;
 265                         break;
 266
 267                 /*
 268                  * Otherwide, this is a priviledged mode, and *all* the
 269                  * registers must be narrowed to 32bit.
 270                  */
 271                 default:
 272                         nr_reg = 31;
 273                         break;
 274                 }
 275
 276                 for (i = 0; i < nr_reg; i++)
 277                         vcpu_set_reg(vcpu, i, (u32)vcpu_get_reg(vcpu, i));
 278
 279                 *vcpu_pc(vcpu) = (u32)*vcpu_pc(vcpu);
 280         }
 281 out:
 282         return err;
 283 }
 284
 285 #define vq_word(vq) (((vq) - SVE_VQ_MIN) / 64)
 286 #define vq_mask(vq) ((u64)1 << ((vq) - SVE_VQ_MIN) % 64)
 287 #define vq_present(vqs, vq) (!!((vqs)[vq_word(vq)] & vq_mask(vq)))
 288
 289 static int get_sve_vls(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 290 {
 291         unsigned int max_vq, vq;
 292         u64 vqs[KVM_ARM64_SVE_VLS_WORDS];
 293
 294         if (!vcpu_has_sve(vcpu))
 295                 return -ENOENT;
 296
 297         if (WARN_ON(!sve_vl_valid(vcpu->arch.sve_max_vl)))
 298                 return -EINVAL;
 299
 300         memset(vqs, 0, sizeof(vqs));
 301
 302         max_vq = vcpu_sve_max_vq(vcpu);
 303         for (vq = SVE_VQ_MIN; vq <= max_vq; ++vq)
 304                 if (sve_vq_available(vq))
 305                         vqs[vq_word(vq)] |= vq_mask(vq);
 306
 307         if (copy_to_user((void __user *)reg->addr, vqs, sizeof(vqs)))
 308                 return -EFAULT;
 309
 310         return 0;
 311 }
 312
 313 static int set_sve_vls(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 314 {
 315         unsigned int max_vq, vq;
 316         u64 vqs[KVM_ARM64_SVE_VLS_WORDS];
 317
 318         if (!vcpu_has_sve(vcpu))
 319                 return -ENOENT;
 320
 321         if (kvm_arm_vcpu_sve_finalized(vcpu))
 322                 return -EPERM; /* too late! */
 323
 324         if (WARN_ON(vcpu->arch.sve_state))
 325                 return -EINVAL;
 326
 327         if (copy_from_user(vqs, (const void __user *)reg->addr, sizeof(vqs)))
 328                 return -EFAULT;
 329
 330         max_vq = 0;
 331         for (vq = SVE_VQ_MIN; vq <= SVE_VQ_MAX; ++vq)
 332                 if (vq_present(vqs, vq))
 333                         max_vq = vq;
 334
 335         if (max_vq > sve_vq_from_vl(kvm_sve_max_vl))
 336                 return -EINVAL;
 337
 338         /*
 339          * Vector lengths supported by the host can't currently be
 340          * hidden from the guest individually: instead we can only set a
 341          * maximum via ZCR_EL2.LEN.  So, make sure the available vector
 342          * lengths match the set requested exactly up to the requested
 343          * maximum:
 344          */
 345         for (vq = SVE_VQ_MIN; vq <= max_vq; ++vq)
 346                 if (vq_present(vqs, vq) != sve_vq_available(vq))
 347                         return -EINVAL;
 348
 349         /* Can't run with no vector lengths at all: */
 350         if (max_vq < SVE_VQ_MIN)
 351                 return -EINVAL;
 352
 353         /* vcpu->arch.sve_state will be alloc'd by kvm_vcpu_finalize_sve() */
 354         vcpu->arch.sve_max_vl = sve_vl_from_vq(max_vq);
 355
 356         return 0;
 357 }
 358
 359 #define SVE_REG_SLICE_SHIFT     0
 360 #define SVE_REG_SLICE_BITS      5
 361 #define SVE_REG_ID_SHIFT        (SVE_REG_SLICE_SHIFT + SVE_REG_SLICE_BITS)
 362 #define SVE_REG_ID_BITS         5
 363
 364 #define SVE_REG_SLICE_MASK                                      \
 365         GENMASK(SVE_REG_SLICE_SHIFT + SVE_REG_SLICE_BITS - 1,   \
 366                 SVE_REG_SLICE_SHIFT)
 367 #define SVE_REG_ID_MASK                                                 \
 368         GENMASK(SVE_REG_ID_SHIFT + SVE_REG_ID_BITS - 1, SVE_REG_ID_SHIFT)
 369
 370 #define SVE_NUM_SLICES (1 << SVE_REG_SLICE_BITS)
 371
 372 #define KVM_SVE_ZREG_SIZE KVM_REG_SIZE(KVM_REG_ARM64_SVE_ZREG(0, 0))
 373 #define KVM_SVE_PREG_SIZE KVM_REG_SIZE(KVM_REG_ARM64_SVE_PREG(0, 0))
 374
 375 /*
 376  * Number of register slices required to cover each whole SVE register.
 377  * NOTE: Only the first slice every exists, for now.
 378  * If you are tempted to modify this, you must also rework sve_reg_to_region()
 379  * to match:
 380  */
 381 #define vcpu_sve_slices(vcpu) 1
 382
 383 /* Bounds of a single SVE register slice within vcpu->arch.sve_state */
 384 struct sve_state_reg_region {
 385         unsigned int koffset;   /* offset into sve_state in kernel memory */
 386         unsigned int klen;      /* length in kernel memory */
 387         unsigned int upad;      /* extra trailing padding in user memory */
 388 };
 389
 390 /*
 391  * Validate SVE register ID and get sanitised bounds for user/kernel SVE
 392  * register copy
 393  */
 394 static int sve_reg_to_region(struct sve_state_reg_region *region,
 395                              struct kvm_vcpu *vcpu,
 396                              const struct kvm_one_reg *reg)
 397 {
 398         /* reg ID ranges for Z- registers */
 399         const u64 zreg_id_min = KVM_REG_ARM64_SVE_ZREG(0, 0);
 400         const u64 zreg_id_max = KVM_REG_ARM64_SVE_ZREG(SVE_NUM_ZREGS - 1,
 401                                                        SVE_NUM_SLICES - 1);
 402
 403         /* reg ID ranges for P- registers and FFR (which are contiguous) */
 404         const u64 preg_id_min = KVM_REG_ARM64_SVE_PREG(0, 0);
 405         const u64 preg_id_max = KVM_REG_ARM64_SVE_FFR(SVE_NUM_SLICES - 1);
 406
 407         unsigned int vq;
 408         unsigned int reg_num;
 409
 410         unsigned int reqoffset, reqlen; /* User-requested offset and length */
 411         unsigned int maxlen; /* Maximum permitted length */
 412
 413         size_t sve_state_size;
 414
 415         const u64 last_preg_id = KVM_REG_ARM64_SVE_PREG(SVE_NUM_PREGS - 1,
 416                                                         SVE_NUM_SLICES - 1);
 417
 418         /* Verify that the P-regs and FFR really do have contiguous IDs: */
 419         BUILD_BUG_ON(KVM_REG_ARM64_SVE_FFR(0) != last_preg_id + 1);
 420
 421         /* Verify that we match the UAPI header: */
 422         BUILD_BUG_ON(SVE_NUM_SLICES != KVM_ARM64_SVE_MAX_SLICES);
 423
 424         reg_num = (reg->id & SVE_REG_ID_MASK) >> SVE_REG_ID_SHIFT;
 425
 426         if (reg->id >= zreg_id_min && reg->id <= zreg_id_max) {
 427                 if (!vcpu_has_sve(vcpu) || (reg->id & SVE_REG_SLICE_MASK) > 0)
 428                         return -ENOENT;
 429
 430                 vq = vcpu_sve_max_vq(vcpu);
 431
 432                 reqoffset = SVE_SIG_ZREG_OFFSET(vq, reg_num) -
 433                                 SVE_SIG_REGS_OFFSET;
 434                 reqlen = KVM_SVE_ZREG_SIZE;
 435                 maxlen = SVE_SIG_ZREG_SIZE(vq);
 436         } else if (reg->id >= preg_id_min && reg->id <= preg_id_max) {
 437                 if (!vcpu_has_sve(vcpu) || (reg->id & SVE_REG_SLICE_MASK) > 0)
 438                         return -ENOENT;
 439
 440                 vq = vcpu_sve_max_vq(vcpu);
 441
 442                 reqoffset = SVE_SIG_PREG_OFFSET(vq, reg_num) -
 443                                 SVE_SIG_REGS_OFFSET;
 444                 reqlen = KVM_SVE_PREG_SIZE;
 445                 maxlen = SVE_SIG_PREG_SIZE(vq);
 446         } else {
 447                 return -EINVAL;
 448         }
 449
 450         sve_state_size = vcpu_sve_state_size(vcpu);
 451         if (WARN_ON(!sve_state_size))
 452                 return -EINVAL;
 453
 454         region->koffset = array_index_nospec(reqoffset, sve_state_size);
 455         region->klen = min(maxlen, reqlen);
 456         region->upad = reqlen - region->klen;
 457
 458         return 0;
 459 }
 460
 461 static int get_sve_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 462 {
 463         int ret;
 464         struct sve_state_reg_region region;
 465         char __user *uptr = (char __user *)reg->addr;
 466
 467         /* Handle the KVM_REG_ARM64_SVE_VLS pseudo-reg as a special case: */
 468         if (reg->id == KVM_REG_ARM64_SVE_VLS)
 469                 return get_sve_vls(vcpu, reg);
 470
 471         /* Try to interpret reg ID as an architectural SVE register... */
 472         ret = sve_reg_to_region(&region, vcpu, reg);
 473         if (ret)
 474                 return ret;
 475
 476         if (!kvm_arm_vcpu_sve_finalized(vcpu))
 477                 return -EPERM;
 478
 479         if (copy_to_user(uptr, vcpu->arch.sve_state + region.koffset,
 480                          region.klen) ||
 481             clear_user(uptr + region.klen, region.upad))
 482                 return -EFAULT;
 483
 484         return 0;
 485 }
 486
 487 static int set_sve_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 488 {
 489         int ret;
 490         struct sve_state_reg_region region;
 491         const char __user *uptr = (const char __user *)reg->addr;
 492
 493         /* Handle the KVM_REG_ARM64_SVE_VLS pseudo-reg as a special case: */
 494         if (reg->id == KVM_REG_ARM64_SVE_VLS)
 495                 return set_sve_vls(vcpu, reg);
 496
 497         /* Try to interpret reg ID as an architectural SVE register... */
 498         ret = sve_reg_to_region(&region, vcpu, reg);
 499         if (ret)
 500                 return ret;
 501
 502         if (!kvm_arm_vcpu_sve_finalized(vcpu))
 503                 return -EPERM;
 504
 505         if (copy_from_user(vcpu->arch.sve_state + region.koffset, uptr,
 506                            region.klen))
 507                 return -EFAULT;
 508
 509         return 0;
 510 }
 511
 512 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 513 {
 514         return -EINVAL;
 515 }
 516
 517 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 518 {
 519         return -EINVAL;
 520 }
 521
 522 static int copy_core_reg_indices(const struct kvm_vcpu *vcpu,
 523                                  u64 __user *uindices)
 524 {
 525         unsigned int i;
 526         int n = 0;
 527
 528         for (i = 0; i < sizeof(struct kvm_regs) / sizeof(__u32); i++) {
 529                 u64 reg = KVM_REG_ARM64 | KVM_REG_ARM_CORE | i;
 530                 int size = core_reg_size_from_offset(vcpu, i);
 531
 532                 if (size < 0)
 533                         continue;
 534
 535                 switch (size) {
 536                 case sizeof(__u32):
 537                         reg |= KVM_REG_SIZE_U32;
 538                         break;
 539
 540                 case sizeof(__u64):
 541                         reg |= KVM_REG_SIZE_U64;
 542                         break;
 543
 544                 case sizeof(__uint128_t):
 545                         reg |= KVM_REG_SIZE_U128;
 546                         break;
 547
 548                 default:
 549                         WARN_ON(1);
 550                         continue;
 551                 }
 552
 553                 if (uindices) {
 554                         if (put_user(reg, uindices))
 555                                 return -EFAULT;
 556                         uindices++;
 557                 }
 558
 559                 n++;
 560         }
 561
 562         return n;
 563 }
 564
 565 static unsigned long num_core_regs(const struct kvm_vcpu *vcpu)
 566 {
 567         return copy_core_reg_indices(vcpu, NULL);
 568 }
 569
 570 /**
 571  * ARM64 versions of the TIMER registers, always available on arm64
 572  */
 573
 574 #define NUM_TIMER_REGS 3
 575
 576 static bool is_timer_reg(u64 index)
 577 {
 578         switch (index) {
 579         case KVM_REG_ARM_TIMER_CTL:
 580         case KVM_REG_ARM_TIMER_CNT:
 581         case KVM_REG_ARM_TIMER_CVAL:
 582                 return true;
 583         }
 584         return false;
 585 }
 586
 587 static int copy_timer_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
 588 {
 589         if (put_user(KVM_REG_ARM_TIMER_CTL, uindices))
 590                 return -EFAULT;
 591         uindices++;
 592         if (put_user(KVM_REG_ARM_TIMER_CNT, uindices))
 593                 return -EFAULT;
 594         uindices++;
 595         if (put_user(KVM_REG_ARM_TIMER_CVAL, uindices))
 596                 return -EFAULT;
 597
 598         return 0;
 599 }
 600
 601 static int set_timer_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 602 {
 603         void __user *uaddr = (void __user *)(long)reg->addr;
 604         u64 val;
 605         int ret;
 606
 607         ret = copy_from_user(&val, uaddr, KVM_REG_SIZE(reg->id));
 608         if (ret != 0)
 609                 return -EFAULT;
 610
 611         return kvm_arm_timer_set_reg(vcpu, reg->id, val);
 612 }
 613
 614 static int get_timer_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 615 {
 616         void __user *uaddr = (void __user *)(long)reg->addr;
 617         u64 val;
 618
 619         val = kvm_arm_timer_get_reg(vcpu, reg->id);
 620         return copy_to_user(uaddr, &val, KVM_REG_SIZE(reg->id)) ? -EFAULT : 0;
 621 }
 622
 623 static unsigned long num_sve_regs(const struct kvm_vcpu *vcpu)
 624 {
 625         const unsigned int slices = vcpu_sve_slices(vcpu);
 626
 627         if (!vcpu_has_sve(vcpu))
 628                 return 0;
 629
 630         /* Policed by KVM_GET_REG_LIST: */
 631         WARN_ON(!kvm_arm_vcpu_sve_finalized(vcpu));
 632
 633         return slices * (SVE_NUM_PREGS + SVE_NUM_ZREGS + 1 /* FFR */)
 634                 + 1; /* KVM_REG_ARM64_SVE_VLS */
 635 }
 636
 637 static int copy_sve_reg_indices(const struct kvm_vcpu *vcpu,
 638                                 u64 __user *uindices)
 639 {
 640         const unsigned int slices = vcpu_sve_slices(vcpu);
 641         u64 reg;
 642         unsigned int i, n;
 643         int num_regs = 0;
 644
 645         if (!vcpu_has_sve(vcpu))
 646                 return 0;
 647
 648         /* Policed by KVM_GET_REG_LIST: */
 649         WARN_ON(!kvm_arm_vcpu_sve_finalized(vcpu));
 650
 651         /*
 652          * Enumerate this first, so that userspace can save/restore in
 653          * the order reported by KVM_GET_REG_LIST:
 654          */
 655         reg = KVM_REG_ARM64_SVE_VLS;
 656         if (put_user(reg, uindices++))
 657                 return -EFAULT;
 658         ++num_regs;
 659
 660         for (i = 0; i < slices; i++) {
 661                 for (n = 0; n < SVE_NUM_ZREGS; n++) {
 662                         reg = KVM_REG_ARM64_SVE_ZREG(n, i);
 663                         if (put_user(reg, uindices++))
 664                                 return -EFAULT;
 665                         num_regs++;
 666                 }
 667
 668                 for (n = 0; n < SVE_NUM_PREGS; n++) {
 669                         reg = KVM_REG_ARM64_SVE_PREG(n, i);
 670                         if (put_user(reg, uindices++))
 671                                 return -EFAULT;
 672                         num_regs++;
 673                 }
 674
 675                 reg = KVM_REG_ARM64_SVE_FFR(i);
 676                 if (put_user(reg, uindices++))
 677                         return -EFAULT;
 678                 num_regs++;
 679         }
 680
 681         return num_regs;
 682 }
 683
 684 /**
 685  * kvm_arm_num_regs - how many registers do we present via KVM_GET_ONE_REG
 686  *
 687  * This is for all registers.
 688  */
 689 unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu)
 690 {
 691         unsigned long res = 0;
 692
 693         res += num_core_regs(vcpu);
 694         res += num_sve_regs(vcpu);
 695         res += kvm_arm_num_sys_reg_descs(vcpu);
 696         res += kvm_arm_get_fw_num_regs(vcpu);
 697         res += NUM_TIMER_REGS;
 698
 699         return res;
 700 }
 701
 702 /**
 703  * kvm_arm_copy_reg_indices - get indices of all registers.
 704  *
 705  * We do core registers right here, then we append system regs.
 706  */
 707 int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
 708 {
 709         int ret;
 710
 711         ret = copy_core_reg_indices(vcpu, uindices);
 712         if (ret < 0)
 713                 return ret;
 714         uindices += ret;
 715
 716         ret = copy_sve_reg_indices(vcpu, uindices);
 717         if (ret < 0)
 718                 return ret;
 719         uindices += ret;
 720
 721         ret = kvm_arm_copy_fw_reg_indices(vcpu, uindices);
 722         if (ret < 0)
 723                 return ret;
 724         uindices += kvm_arm_get_fw_num_regs(vcpu);
 725
 726         ret = copy_timer_indices(vcpu, uindices);
 727         if (ret < 0)
 728                 return ret;
 729         uindices += NUM_TIMER_REGS;
 730
 731         return kvm_arm_copy_sys_reg_indices(vcpu, uindices);
 732 }
 733
 734 int kvm_arm_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 735 {
 736         /* We currently use nothing arch-specific in upper 32 bits */
 737         if ((reg->id & ~KVM_REG_SIZE_MASK) >> 32 != KVM_REG_ARM64 >> 32)
 738                 return -EINVAL;
 739
 740         switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
 741         case KVM_REG_ARM_CORE:  return get_core_reg(vcpu, reg);
 742         case KVM_REG_ARM_FW:    return kvm_arm_get_fw_reg(vcpu, reg);
 743         case KVM_REG_ARM64_SVE: return get_sve_reg(vcpu, reg);
 744         }
 745
 746         if (is_timer_reg(reg->id))
 747                 return get_timer_reg(vcpu, reg);
 748
 749         return kvm_arm_sys_reg_get_reg(vcpu, reg);
 750 }
 751
 752 int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 753 {
 754         /* We currently use nothing arch-specific in upper 32 bits */
 755         if ((reg->id & ~KVM_REG_SIZE_MASK) >> 32 != KVM_REG_ARM64 >> 32)
 756                 return -EINVAL;
 757
 758         switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
 759         case KVM_REG_ARM_CORE:  return set_core_reg(vcpu, reg);
 760         case KVM_REG_ARM_FW:    return kvm_arm_set_fw_reg(vcpu, reg);
 761         case KVM_REG_ARM64_SVE: return set_sve_reg(vcpu, reg);
 762         }
 763
 764         if (is_timer_reg(reg->id))
 765                 return set_timer_reg(vcpu, reg);
 766
 767         return kvm_arm_sys_reg_set_reg(vcpu, reg);
 768 }
 769
 770 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 771                                   struct kvm_sregs *sregs)
 772 {
 773         return -EINVAL;
 774 }
 775
 776 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 777                                   struct kvm_sregs *sregs)
 778 {
 779         return -EINVAL;
 780 }
 781
 782 int __kvm_arm_vcpu_get_events(struct kvm_vcpu *vcpu,
 783                               struct kvm_vcpu_events *events)
 784 {
 785         events->exception.serror_pending = !!(vcpu->arch.hcr_el2 & HCR_VSE);
 786         events->exception.serror_has_esr = cpus_have_const_cap(ARM64_HAS_RAS_EXTN);
 787
 788         if (events->exception.serror_pending && events->exception.serror_has_esr)
 789                 events->exception.serror_esr = vcpu_get_vsesr(vcpu);
 790
 791         /*
 792          * We never return a pending ext_dabt here because we deliver it to
 793          * the virtual CPU directly when setting the event and it's no longer
 794          * 'pending' at this point.
 795          */
 796
 797         return 0;
 798 }
 799
 800 int __kvm_arm_vcpu_set_events(struct kvm_vcpu *vcpu,
 801                               struct kvm_vcpu_events *events)
 802 {
 803         bool serror_pending = events->exception.serror_pending;
 804         bool has_esr = events->exception.serror_has_esr;
 805         bool ext_dabt_pending = events->exception.ext_dabt_pending;
 806
 807         if (serror_pending && has_esr) {
 808                 if (!cpus_have_const_cap(ARM64_HAS_RAS_EXTN))
 809                         return -EINVAL;
 810
 811                 if (!((events->exception.serror_esr) & ~ESR_ELx_ISS_MASK))
 812                         kvm_set_sei_esr(vcpu, events->exception.serror_esr);
 813                 else
 814                         return -EINVAL;
 815         } else if (serror_pending) {
 816                 kvm_inject_vabt(vcpu);
 817         }
 818
 819         if (ext_dabt_pending)
 820                 kvm_inject_dabt(vcpu, kvm_vcpu_get_hfar(vcpu));
 821
 822         return 0;
 823 }
 824
 825 int __attribute_const__ kvm_target_cpu(void)
 826 {
 827         unsigned long implementor = read_cpuid_implementor();
 828         unsigned long part_number = read_cpuid_part_number();
 829
 830         switch (implementor) {
 831         case ARM_CPU_IMP_ARM:
 832                 switch (part_number) {
 833                 case ARM_CPU_PART_AEM_V8:
 834                         return KVM_ARM_TARGET_AEM_V8;
 835                 case ARM_CPU_PART_FOUNDATION:
 836                         return KVM_ARM_TARGET_FOUNDATION_V8;
 837                 case ARM_CPU_PART_CORTEX_A53:
 838                         return KVM_ARM_TARGET_CORTEX_A53;
 839                 case ARM_CPU_PART_CORTEX_A57:
 840                         return KVM_ARM_TARGET_CORTEX_A57;
 841                 }
 842                 break;
 843         case ARM_CPU_IMP_APM:
 844                 switch (part_number) {
 845                 case APM_CPU_PART_POTENZA:
 846                         return KVM_ARM_TARGET_XGENE_POTENZA;
 847                 }
 848                 break;
 849         }
 850
 851         /* Return a default generic target */
 852         return KVM_ARM_TARGET_GENERIC_V8;
 853 }
 854
 855 int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init)
 856 {
 857         int target = kvm_target_cpu();
 858
 859         if (target < 0)
 860                 return -ENODEV;
 861
 862         memset(init, 0, sizeof(*init));
 863
 864         /*
 865          * For now, we don't return any features.
 866          * In future, we might use features to return target
 867          * specific features available for the preferred
 868          * target type.
 869          */
 870         init->target = (__u32)target;
 871
 872         return 0;
 873 }
 874
 875 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 876 {
 877         return -EINVAL;
 878 }
 879
 880 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 881 {
 882         return -EINVAL;
 883 }
 884
 885 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
 886                                   struct kvm_translation *tr)
 887 {
 888         return -EINVAL;
 889 }
 890
 891 /**
 892  * kvm_arch_vcpu_ioctl_set_guest_debug - set up guest debugging
 893  * @kvm:        pointer to the KVM struct
 894  * @kvm_guest_debug: the ioctl data buffer
 895  *
 896  * This sets up and enables the VM for guest debugging. Userspace
 897  * passes in a control flag to enable different debug types and
 898  * potentially other architecture specific information in the rest of
 899  * the structure.
 900  */
 901 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 902                                         struct kvm_guest_debug *dbg)
 903 {
 904         int ret = 0;
 905
 906         trace_kvm_set_guest_debug(vcpu, dbg->control);
 907
 908         if (dbg->control & ~KVM_GUESTDBG_VALID_MASK) {
 909                 ret = -EINVAL;
 910                 goto out;
 911         }
 912
 913         if (dbg->control & KVM_GUESTDBG_ENABLE) {
 914                 vcpu->guest_debug = dbg->control;
 915
 916                 /* Hardware assisted Break and Watch points */
 917                 if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) {
 918                         vcpu->arch.external_debug_state = dbg->arch;
 919                 }
 920
 921         } else {
 922                 /* If not enabled clear all flags */
 923                 vcpu->guest_debug = 0;
 924         }
 925
 926 out:
 927         return ret;
 928 }
 929
 930 int kvm_arm_vcpu_arch_set_attr(struct kvm_vcpu *vcpu,
 931                                struct kvm_device_attr *attr)
 932 {
 933         int ret;
 934
 935         switch (attr->group) {
 936         case KVM_ARM_VCPU_PMU_V3_CTRL:
 937                 ret = kvm_arm_pmu_v3_set_attr(vcpu, attr);
 938                 break;
 939         case KVM_ARM_VCPU_TIMER_CTRL:
 940                 ret = kvm_arm_timer_set_attr(vcpu, attr);
 941                 break;
 942         case KVM_ARM_VCPU_PVTIME_CTRL:
 943                 ret = kvm_arm_pvtime_set_attr(vcpu, attr);
 944                 break;
 945         default:
 946                 ret = -ENXIO;
 947                 break;
 948         }
 949
 950         return ret;
 951 }
 952
 953 int kvm_arm_vcpu_arch_get_attr(struct kvm_vcpu *vcpu,
 954                                struct kvm_device_attr *attr)
 955 {
 956         int ret;
 957
 958         switch (attr->group) {
 959         case KVM_ARM_VCPU_PMU_V3_CTRL:
 960                 ret = kvm_arm_pmu_v3_get_attr(vcpu, attr);
 961                 break;
 962         case KVM_ARM_VCPU_TIMER_CTRL:
 963                 ret = kvm_arm_timer_get_attr(vcpu, attr);
 964                 break;
 965         case KVM_ARM_VCPU_PVTIME_CTRL:
 966                 ret = kvm_arm_pvtime_get_attr(vcpu, attr);
 967                 break;
 968         default:
 969                 ret = -ENXIO;
 970                 break;
 971         }
 972
 973         return ret;
 974 }
 975
 976 int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu,
 977                                struct kvm_device_attr *attr)
 978 {
 979         int ret;
 980
 981         switch (attr->group) {
 982         case KVM_ARM_VCPU_PMU_V3_CTRL:
 983                 ret = kvm_arm_pmu_v3_has_attr(vcpu, attr);
 984                 break;
 985         case KVM_ARM_VCPU_TIMER_CTRL:
 986                 ret = kvm_arm_timer_has_attr(vcpu, attr);
 987                 break;
 988         case KVM_ARM_VCPU_PVTIME_CTRL:
 989                 ret = kvm_arm_pvtime_has_attr(vcpu, attr);
 990                 break;
 991         default:
 992                 ret = -ENXIO;
 993                 break;
 994         }
 995
 996         return ret;
 997 }
 998
 999 long kvm_vm_ioctl_mte_copy_tags(struct kvm *kvm,
1000                                 struct kvm_arm_copy_mte_tags *copy_tags)
1001 {
1002         gpa_t guest_ipa = copy_tags->guest_ipa;
1003         size_t length = copy_tags->length;
1004         void __user *tags = copy_tags->addr;
1005         gpa_t gfn;
1006         bool write = !(copy_tags->flags & KVM_ARM_TAGS_FROM_GUEST);
1007         int ret = 0;
1008
1009         if (!kvm_has_mte(kvm))
1010                 return -EINVAL;
1011
1012         if (copy_tags->reserved[0] || copy_tags->reserved[1])
1013                 return -EINVAL;
1014
1015         if (copy_tags->flags & ~KVM_ARM_TAGS_FROM_GUEST)
1016                 return -EINVAL;
1017
1018         if (length & ~PAGE_MASK || guest_ipa & ~PAGE_MASK)
1019                 return -EINVAL;
1020
1021         gfn = gpa_to_gfn(guest_ipa);
1022
1023         mutex_lock(&kvm->slots_lock);
1024
1025         while (length > 0) {
1026                 kvm_pfn_t pfn = gfn_to_pfn_prot(kvm, gfn, write, NULL);
1027                 void *maddr;
1028                 unsigned long num_tags;
1029                 struct page *page;
1030
1031                 if (is_error_noslot_pfn(pfn)) {
1032                         ret = -EFAULT;
1033                         goto out;
1034                 }
1035
1036                 page = pfn_to_online_page(pfn);
1037                 if (!page) {
1038                         /* Reject ZONE_DEVICE memory */
1039                         ret = -EFAULT;
1040                         goto out;
1041                 }
1042                 maddr = page_address(page);
1043
1044                 if (!write) {
1045                         if (test_bit(PG_mte_tagged, &page->flags))
1046                                 num_tags = mte_copy_tags_to_user(tags, maddr,
1047                                                         MTE_GRANULES_PER_PAGE);
1048                         else
1049                                 /* No tags in memory, so write zeros */
1050                                 num_tags = MTE_GRANULES_PER_PAGE -
1051                                         clear_user(tags, MTE_GRANULES_PER_PAGE);
1052                         kvm_release_pfn_clean(pfn);
1053                 } else {
1054                         num_tags = mte_copy_tags_from_user(maddr, tags,
1055                                                         MTE_GRANULES_PER_PAGE);
1056                         kvm_release_pfn_dirty(pfn);
1057                 }
1058
1059                 if (num_tags != MTE_GRANULES_PER_PAGE) {
1060                         ret = -EFAULT;
1061                         goto out;
1062                 }
1063
1064                 /* Set the flag after checking the write completed fully */
1065                 if (write)
1066                         set_bit(PG_mte_tagged, &page->flags);
1067
1068                 gfn++;
1069                 tags += num_tags;
1070                 length -= PAGE_SIZE;
1071         }
1072
1073 out:
1074         mutex_unlock(&kvm->slots_lock);
1075         /* If some data has been copied report the number of bytes copied */
1076         if (length != copy_tags->length)
1077                 return copy_tags->length - length;
1078         return ret;
1079 }