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