arch/arm64/kvm/guest.c

   1 /*
   2  * Copyright (C) 2012,2013 - ARM Ltd
   3  * Author: Marc Zyngier <marc.zyngier@arm.com>
   4  *
   5  * Derived from arch/arm/kvm/guest.c:
   6  * Copyright (C) 2012 - Virtual Open Systems and Columbia University
   7  * Author: Christoffer Dall <c.dall@virtualopensystems.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <linux/bits.h>
  23 #include <linux/errno.h>
  24 #include <linux/err.h>
  25 #include <linux/nospec.h>
  26 #include <linux/kernel.h>
  27 #include <linux/kvm_host.h>
  28 #include <linux/module.h>
  29 #include <linux/stddef.h>
  30 #include <linux/string.h>
  31 #include <linux/vmalloc.h>
  32 #include <linux/fs.h>
  33 #include <kvm/arm_psci.h>
  34 #include <asm/cputype.h>
  35 #include <linux/uaccess.h>
  36 #include <asm/fpsimd.h>
  37 #include <asm/kvm.h>
  38 #include <asm/kvm_emulate.h>
  39 #include <asm/kvm_coproc.h>
  40 #include <asm/kvm_host.h>
  41 #include <asm/sigcontext.h>
  42
  43 #include "trace.h"
  44
  45 #define VM_STAT(x) { #x, offsetof(struct kvm, stat.x), KVM_STAT_VM }
  46 #define VCPU_STAT(x) { #x, offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU }
  47
  48 struct kvm_stats_debugfs_item debugfs_entries[] = {
  49         VCPU_STAT(hvc_exit_stat),
  50         VCPU_STAT(wfe_exit_stat),
  51         VCPU_STAT(wfi_exit_stat),
  52         VCPU_STAT(mmio_exit_user),
  53         VCPU_STAT(mmio_exit_kernel),
  54         VCPU_STAT(exits),
  55         { NULL }
  56 };
  57
  58 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
  59 {
  60         return 0;
  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 validate_core_offset(const struct kvm_vcpu *vcpu,
  75                                 const struct kvm_one_reg *reg)
  76 {
  77         u64 off = core_reg_offset_from_id(reg->id);
  78         int size;
  79
  80         switch (off) {
  81         case KVM_REG_ARM_CORE_REG(regs.regs[0]) ...
  82              KVM_REG_ARM_CORE_REG(regs.regs[30]):
  83         case KVM_REG_ARM_CORE_REG(regs.sp):
  84         case KVM_REG_ARM_CORE_REG(regs.pc):
  85         case KVM_REG_ARM_CORE_REG(regs.pstate):
  86         case KVM_REG_ARM_CORE_REG(sp_el1):
  87         case KVM_REG_ARM_CORE_REG(elr_el1):
  88         case KVM_REG_ARM_CORE_REG(spsr[0]) ...
  89              KVM_REG_ARM_CORE_REG(spsr[KVM_NR_SPSR - 1]):
  90                 size = sizeof(__u64);
  91                 break;
  92
  93         case KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]) ...
  94              KVM_REG_ARM_CORE_REG(fp_regs.vregs[31]):
  95                 size = sizeof(__uint128_t);
  96                 break;
  97
  98         case KVM_REG_ARM_CORE_REG(fp_regs.fpsr):
  99         case KVM_REG_ARM_CORE_REG(fp_regs.fpcr):
 100                 size = sizeof(__u32);
 101                 break;
 102
 103         default:
 104                 return -EINVAL;
 105         }
 106
 107         if (KVM_REG_SIZE(reg->id) != size ||
 108             !IS_ALIGNED(off, size / sizeof(__u32)))
 109                 return -EINVAL;
 110
 111         /*
 112          * The KVM_REG_ARM64_SVE regs must be used instead of
 113          * KVM_REG_ARM_CORE for accessing the FPSIMD V-registers on
 114          * SVE-enabled vcpus:
 115          */
 116         if (vcpu_has_sve(vcpu) && core_reg_offset_is_vreg(off))
 117                 return -EINVAL;
 118
 119         return 0;
 120 }
 121
 122 static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 123 {
 124         /*
 125          * Because the kvm_regs structure is a mix of 32, 64 and
 126          * 128bit fields, we index it as if it was a 32bit
 127          * array. Hence below, nr_regs is the number of entries, and
 128          * off the index in the "array".
 129          */
 130         __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
 131         struct kvm_regs *regs = vcpu_gp_regs(vcpu);
 132         int nr_regs = sizeof(*regs) / sizeof(__u32);
 133         u32 off;
 134
 135         /* Our ID is an index into the kvm_regs struct. */
 136         off = core_reg_offset_from_id(reg->id);
 137         if (off >= nr_regs ||
 138             (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
 139                 return -ENOENT;
 140
 141         if (validate_core_offset(vcpu, reg))
 142                 return -EINVAL;
 143
 144         if (copy_to_user(uaddr, ((u32 *)regs) + off, KVM_REG_SIZE(reg->id)))
 145                 return -EFAULT;
 146
 147         return 0;
 148 }
 149
 150 static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 151 {
 152         __u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;
 153         struct kvm_regs *regs = vcpu_gp_regs(vcpu);
 154         int nr_regs = sizeof(*regs) / sizeof(__u32);
 155         __uint128_t tmp;
 156         void *valp = &tmp;
 157         u64 off;
 158         int err = 0;
 159
 160         /* Our ID is an index into the kvm_regs struct. */
 161         off = core_reg_offset_from_id(reg->id);
 162         if (off >= nr_regs ||
 163             (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)
 164                 return -ENOENT;
 165
 166         if (validate_core_offset(vcpu, reg))
 167                 return -EINVAL;
 168
 169         if (KVM_REG_SIZE(reg->id) > sizeof(tmp))
 170                 return -EINVAL;
 171
 172         if (copy_from_user(valp, uaddr, KVM_REG_SIZE(reg->id))) {
 173                 err = -EFAULT;
 174                 goto out;
 175         }
 176
 177         if (off == KVM_REG_ARM_CORE_REG(regs.pstate)) {
 178                 u64 mode = (*(u64 *)valp) & PSR_AA32_MODE_MASK;
 179                 switch (mode) {
 180                 case PSR_AA32_MODE_USR:
 181                         if (!system_supports_32bit_el0())
 182                                 return -EINVAL;
 183                         break;
 184                 case PSR_AA32_MODE_FIQ:
 185                 case PSR_AA32_MODE_IRQ:
 186                 case PSR_AA32_MODE_SVC:
 187                 case PSR_AA32_MODE_ABT:
 188                 case PSR_AA32_MODE_UND:
 189                         if (!vcpu_el1_is_32bit(vcpu))
 190                                 return -EINVAL;
 191                         break;
 192                 case PSR_MODE_EL0t:
 193                 case PSR_MODE_EL1t:
 194                 case PSR_MODE_EL1h:
 195                         if (vcpu_el1_is_32bit(vcpu))
 196                                 return -EINVAL;
 197                         break;
 198                 default:
 199                         err = -EINVAL;
 200                         goto out;
 201                 }
 202         }
 203
 204         memcpy((u32 *)regs + off, valp, KVM_REG_SIZE(reg->id));
 205 out:
 206         return err;
 207 }
 208
 209 #define vq_word(vq) (((vq) - SVE_VQ_MIN) / 64)
 210 #define vq_mask(vq) ((u64)1 << ((vq) - SVE_VQ_MIN) % 64)
 211
 212 static bool vq_present(
 213         const u64 (*const vqs)[DIV_ROUND_UP(SVE_VQ_MAX - SVE_VQ_MIN + 1, 64)],
 214         unsigned int vq)
 215 {
 216         return (*vqs)[vq_word(vq)] & vq_mask(vq);
 217 }
 218
 219 static int get_sve_vls(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 220 {
 221         unsigned int max_vq, vq;
 222         u64 vqs[DIV_ROUND_UP(SVE_VQ_MAX - SVE_VQ_MIN + 1, 64)];
 223
 224         if (WARN_ON(!sve_vl_valid(vcpu->arch.sve_max_vl)))
 225                 return -EINVAL;
 226
 227         memset(vqs, 0, sizeof(vqs));
 228
 229         max_vq = sve_vq_from_vl(vcpu->arch.sve_max_vl);
 230         for (vq = SVE_VQ_MIN; vq <= max_vq; ++vq)
 231                 if (sve_vq_available(vq))
 232                         vqs[vq_word(vq)] |= vq_mask(vq);
 233
 234         if (copy_to_user((void __user *)reg->addr, vqs, sizeof(vqs)))
 235                 return -EFAULT;
 236
 237         return 0;
 238 }
 239
 240 static int set_sve_vls(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 241 {
 242         unsigned int max_vq, vq;
 243         u64 vqs[DIV_ROUND_UP(SVE_VQ_MAX - SVE_VQ_MIN + 1, 64)];
 244
 245         if (kvm_arm_vcpu_sve_finalized(vcpu))
 246                 return -EPERM; /* too late! */
 247
 248         if (WARN_ON(vcpu->arch.sve_state))
 249                 return -EINVAL;
 250
 251         if (copy_from_user(vqs, (const void __user *)reg->addr, sizeof(vqs)))
 252                 return -EFAULT;
 253
 254         max_vq = 0;
 255         for (vq = SVE_VQ_MIN; vq <= SVE_VQ_MAX; ++vq)
 256                 if (vq_present(&vqs, vq))
 257                         max_vq = vq;
 258
 259         if (max_vq > sve_vq_from_vl(kvm_sve_max_vl))
 260                 return -EINVAL;
 261
 262         for (vq = SVE_VQ_MIN; vq <= max_vq; ++vq)
 263                 if (vq_present(&vqs, vq) != sve_vq_available(vq))
 264                         return -EINVAL;
 265
 266         /* Can't run with no vector lengths at all: */
 267         if (max_vq < SVE_VQ_MIN)
 268                 return -EINVAL;
 269
 270         /* vcpu->arch.sve_state will be alloc'd by kvm_vcpu_finalize_sve() */
 271         vcpu->arch.sve_max_vl = sve_vl_from_vq(max_vq);
 272
 273         return 0;
 274 }
 275
 276 #define SVE_REG_SLICE_SHIFT     0
 277 #define SVE_REG_SLICE_BITS      5
 278 #define SVE_REG_ID_SHIFT        (SVE_REG_SLICE_SHIFT + SVE_REG_SLICE_BITS)
 279 #define SVE_REG_ID_BITS         5
 280
 281 #define SVE_REG_SLICE_MASK                                      \
 282         GENMASK(SVE_REG_SLICE_SHIFT + SVE_REG_SLICE_BITS - 1,   \
 283                 SVE_REG_SLICE_SHIFT)
 284 #define SVE_REG_ID_MASK                                                 \
 285         GENMASK(SVE_REG_ID_SHIFT + SVE_REG_ID_BITS - 1, SVE_REG_ID_SHIFT)
 286
 287 #define SVE_NUM_SLICES (1 << SVE_REG_SLICE_BITS)
 288
 289 #define KVM_SVE_ZREG_SIZE KVM_REG_SIZE(KVM_REG_ARM64_SVE_ZREG(0, 0))
 290 #define KVM_SVE_PREG_SIZE KVM_REG_SIZE(KVM_REG_ARM64_SVE_PREG(0, 0))
 291
 292 /*
 293  * number of register slices required to cover each whole SVE register on vcpu
 294  * NOTE: If you are tempted to modify this, you must also to rework
 295  * sve_reg_to_region() to match:
 296  */
 297 #define vcpu_sve_slices(vcpu) 1
 298
 299 /* Bounds of a single SVE register slice within vcpu->arch.sve_state */
 300 struct sve_state_reg_region {
 301         unsigned int koffset;   /* offset into sve_state in kernel memory */
 302         unsigned int klen;      /* length in kernel memory */
 303         unsigned int upad;      /* extra trailing padding in user memory */
 304 };
 305
 306 /* Get sanitised bounds for user/kernel SVE register copy */
 307 static int sve_reg_to_region(struct sve_state_reg_region *region,
 308                              struct kvm_vcpu *vcpu,
 309                              const struct kvm_one_reg *reg)
 310 {
 311         /* reg ID ranges for Z- registers */
 312         const u64 zreg_id_min = KVM_REG_ARM64_SVE_ZREG(0, 0);
 313         const u64 zreg_id_max = KVM_REG_ARM64_SVE_ZREG(SVE_NUM_ZREGS - 1,
 314                                                        SVE_NUM_SLICES - 1);
 315
 316         /* reg ID ranges for P- registers and FFR (which are contiguous) */
 317         const u64 preg_id_min = KVM_REG_ARM64_SVE_PREG(0, 0);
 318         const u64 preg_id_max = KVM_REG_ARM64_SVE_FFR(SVE_NUM_SLICES - 1);
 319
 320         unsigned int vq;
 321         unsigned int reg_num;
 322
 323         unsigned int reqoffset, reqlen; /* User-requested offset and length */
 324         unsigned int maxlen; /* Maxmimum permitted length */
 325
 326         size_t sve_state_size;
 327
 328         /* Only the first slice ever exists, for now: */
 329         if ((reg->id & SVE_REG_SLICE_MASK) != 0)
 330                 return -ENOENT;
 331
 332         vq = sve_vq_from_vl(vcpu->arch.sve_max_vl);
 333
 334         reg_num = (reg->id & SVE_REG_ID_MASK) >> SVE_REG_ID_SHIFT;
 335
 336         if (reg->id >= zreg_id_min && reg->id <= zreg_id_max) {
 337                 reqoffset = SVE_SIG_ZREG_OFFSET(vq, reg_num) -
 338                                 SVE_SIG_REGS_OFFSET;
 339                 reqlen = KVM_SVE_ZREG_SIZE;
 340                 maxlen = SVE_SIG_ZREG_SIZE(vq);
 341         } else if (reg->id >= preg_id_min && reg->id <= preg_id_max) {
 342                 reqoffset = SVE_SIG_PREG_OFFSET(vq, reg_num) -
 343                                 SVE_SIG_REGS_OFFSET;
 344                 reqlen = KVM_SVE_PREG_SIZE;
 345                 maxlen = SVE_SIG_PREG_SIZE(vq);
 346         } else {
 347                 return -ENOENT;
 348         }
 349
 350         sve_state_size = vcpu_sve_state_size(vcpu);
 351         if (!sve_state_size)
 352                 return -EINVAL;
 353
 354         region->koffset = array_index_nospec(reqoffset, sve_state_size);
 355         region->klen = min(maxlen, reqlen);
 356         region->upad = reqlen - region->klen;
 357
 358         return 0;
 359 }
 360
 361 static int get_sve_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 362 {
 363         struct sve_state_reg_region region;
 364         char __user *uptr = (char __user *)reg->addr;
 365
 366         if (!vcpu_has_sve(vcpu))
 367                 return -ENOENT;
 368
 369         /* Handle the KVM_REG_ARM64_SVE_VLS pseudo-reg as a special case: */
 370         if (reg->id == KVM_REG_ARM64_SVE_VLS)
 371                 return get_sve_vls(vcpu, reg);
 372
 373         /* Otherwise, reg is an architectural SVE register... */
 374
 375         if (!kvm_arm_vcpu_sve_finalized(vcpu))
 376                 return -EPERM;
 377
 378         if (sve_reg_to_region(&region, vcpu, reg))
 379                 return -ENOENT;
 380
 381         if (copy_to_user(uptr, vcpu->arch.sve_state + region.koffset,
 382                          region.klen) ||
 383             clear_user(uptr + region.klen, region.upad))
 384                 return -EFAULT;
 385
 386         return 0;
 387 }
 388
 389 static int set_sve_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 390 {
 391         struct sve_state_reg_region region;
 392         const char __user *uptr = (const char __user *)reg->addr;
 393
 394         if (!vcpu_has_sve(vcpu))
 395                 return -ENOENT;
 396
 397         /* Handle the KVM_REG_ARM64_SVE_VLS pseudo-reg as a special case: */
 398         if (reg->id == KVM_REG_ARM64_SVE_VLS)
 399                 return set_sve_vls(vcpu, reg);
 400
 401         /* Otherwise, reg is an architectural SVE register... */
 402
 403         if (!kvm_arm_vcpu_sve_finalized(vcpu))
 404                 return -EPERM;
 405
 406         if (sve_reg_to_region(&region, vcpu, reg))
 407                 return -ENOENT;
 408
 409         if (copy_from_user(vcpu->arch.sve_state + region.koffset, uptr,
 410                            region.klen))
 411                 return -EFAULT;
 412
 413         return 0;
 414 }
 415
 416 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 417 {
 418         return -EINVAL;
 419 }
 420
 421 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 422 {
 423         return -EINVAL;
 424 }
 425
 426 static int copy_core_reg_indices(const struct kvm_vcpu *vcpu,
 427                                  u64 __user *uindices)
 428 {
 429         unsigned int i;
 430         int n = 0;
 431         const u64 core_reg = KVM_REG_ARM64 | KVM_REG_SIZE_U64 | KVM_REG_ARM_CORE;
 432
 433         for (i = 0; i < sizeof(struct kvm_regs) / sizeof(__u32); i++) {
 434                 /*
 435                  * The KVM_REG_ARM64_SVE regs must be used instead of
 436                  * KVM_REG_ARM_CORE for accessing the FPSIMD V-registers on
 437                  * SVE-enabled vcpus:
 438                  */
 439                 if (vcpu_has_sve(vcpu) && core_reg_offset_is_vreg(i))
 440                         continue;
 441
 442                 if (uindices) {
 443                         if (put_user(core_reg | i, uindices))
 444                                 return -EFAULT;
 445                         uindices++;
 446                 }
 447
 448                 n++;
 449         }
 450
 451         return n;
 452 }
 453
 454 static unsigned long num_core_regs(const struct kvm_vcpu *vcpu)
 455 {
 456         return copy_core_reg_indices(vcpu, NULL);
 457 }
 458
 459 /**
 460  * ARM64 versions of the TIMER registers, always available on arm64
 461  */
 462
 463 #define NUM_TIMER_REGS 3
 464
 465 static bool is_timer_reg(u64 index)
 466 {
 467         switch (index) {
 468         case KVM_REG_ARM_TIMER_CTL:
 469         case KVM_REG_ARM_TIMER_CNT:
 470         case KVM_REG_ARM_TIMER_CVAL:
 471                 return true;
 472         }
 473         return false;
 474 }
 475
 476 static int copy_timer_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
 477 {
 478         if (put_user(KVM_REG_ARM_TIMER_CTL, uindices))
 479                 return -EFAULT;
 480         uindices++;
 481         if (put_user(KVM_REG_ARM_TIMER_CNT, uindices))
 482                 return -EFAULT;
 483         uindices++;
 484         if (put_user(KVM_REG_ARM_TIMER_CVAL, uindices))
 485                 return -EFAULT;
 486
 487         return 0;
 488 }
 489
 490 static int set_timer_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 491 {
 492         void __user *uaddr = (void __user *)(long)reg->addr;
 493         u64 val;
 494         int ret;
 495
 496         ret = copy_from_user(&val, uaddr, KVM_REG_SIZE(reg->id));
 497         if (ret != 0)
 498                 return -EFAULT;
 499
 500         return kvm_arm_timer_set_reg(vcpu, reg->id, val);
 501 }
 502
 503 static int get_timer_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 504 {
 505         void __user *uaddr = (void __user *)(long)reg->addr;
 506         u64 val;
 507
 508         val = kvm_arm_timer_get_reg(vcpu, reg->id);
 509         return copy_to_user(uaddr, &val, KVM_REG_SIZE(reg->id)) ? -EFAULT : 0;
 510 }
 511
 512 static unsigned long num_sve_regs(const struct kvm_vcpu *vcpu)
 513 {
 514         /* Only the first slice ever exists, for now */
 515         const unsigned int slices = vcpu_sve_slices(vcpu);
 516
 517         if (!vcpu_has_sve(vcpu))
 518                 return 0;
 519
 520         /* Policed by KVM_GET_REG_LIST: */
 521         WARN_ON(!kvm_arm_vcpu_sve_finalized(vcpu));
 522
 523         return slices * (SVE_NUM_PREGS + SVE_NUM_ZREGS + 1 /* FFR */)
 524                 + 1; /* KVM_REG_ARM64_SVE_VLS */
 525 }
 526
 527 static int copy_sve_reg_indices(const struct kvm_vcpu *vcpu,
 528                                 u64 __user *uindices)
 529 {
 530         /* Only the first slice ever exists, for now */
 531         const unsigned int slices = vcpu_sve_slices(vcpu);
 532         u64 reg;
 533         unsigned int i, n;
 534         int num_regs = 0;
 535
 536         if (!vcpu_has_sve(vcpu))
 537                 return 0;
 538
 539         /* Policed by KVM_GET_REG_LIST: */
 540         WARN_ON(!kvm_arm_vcpu_sve_finalized(vcpu));
 541
 542         /*
 543          * Enumerate this first, so that userspace can save/restore in
 544          * the order reported by KVM_GET_REG_LIST:
 545          */
 546         reg = KVM_REG_ARM64_SVE_VLS;
 547         if (put_user(reg, uindices++))
 548                 return -EFAULT;
 549
 550         ++num_regs;
 551
 552         for (i = 0; i < slices; i++) {
 553                 for (n = 0; n < SVE_NUM_ZREGS; n++) {
 554                         reg = KVM_REG_ARM64_SVE_ZREG(n, i);
 555                         if (put_user(reg, uindices++))
 556                                 return -EFAULT;
 557
 558                         num_regs++;
 559                 }
 560
 561                 for (n = 0; n < SVE_NUM_PREGS; n++) {
 562                         reg = KVM_REG_ARM64_SVE_PREG(n, i);
 563                         if (put_user(reg, uindices++))
 564                                 return -EFAULT;
 565
 566                         num_regs++;
 567                 }
 568
 569                 reg = KVM_REG_ARM64_SVE_FFR(i);
 570                 if (put_user(reg, uindices++))
 571                         return -EFAULT;
 572
 573                 num_regs++;
 574         }
 575
 576         return num_regs;
 577 }
 578
 579 /**
 580  * kvm_arm_num_regs - how many registers do we present via KVM_GET_ONE_REG
 581  *
 582  * This is for all registers.
 583  */
 584 unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu)
 585 {
 586         unsigned long res = 0;
 587
 588         res += num_core_regs(vcpu);
 589         res += num_sve_regs(vcpu);
 590         res += kvm_arm_num_sys_reg_descs(vcpu);
 591         res += kvm_arm_get_fw_num_regs(vcpu);
 592         res += NUM_TIMER_REGS;
 593
 594         return res;
 595 }
 596
 597 /**
 598  * kvm_arm_copy_reg_indices - get indices of all registers.
 599  *
 600  * We do core registers right here, then we append system regs.
 601  */
 602 int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
 603 {
 604         int ret;
 605
 606         ret = copy_core_reg_indices(vcpu, uindices);
 607         if (ret)
 608                 return ret;
 609         uindices += ret;
 610
 611         ret = copy_sve_reg_indices(vcpu, uindices);
 612         if (ret)
 613                 return ret;
 614         uindices += ret;
 615
 616         ret = kvm_arm_copy_fw_reg_indices(vcpu, uindices);
 617         if (ret)
 618                 return ret;
 619         uindices += kvm_arm_get_fw_num_regs(vcpu);
 620
 621         ret = copy_timer_indices(vcpu, uindices);
 622         if (ret)
 623                 return ret;
 624         uindices += NUM_TIMER_REGS;
 625
 626         return kvm_arm_copy_sys_reg_indices(vcpu, uindices);
 627 }
 628
 629 int kvm_arm_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 630 {
 631         /* We currently use nothing arch-specific in upper 32 bits */
 632         if ((reg->id & ~KVM_REG_SIZE_MASK) >> 32 != KVM_REG_ARM64 >> 32)
 633                 return -EINVAL;
 634
 635         switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
 636         case KVM_REG_ARM_CORE:  return get_core_reg(vcpu, reg);
 637         case KVM_REG_ARM_FW:    return kvm_arm_get_fw_reg(vcpu, reg);
 638         case KVM_REG_ARM64_SVE: return get_sve_reg(vcpu, reg);
 639         default: break; /* fall through */
 640         }
 641
 642         if (is_timer_reg(reg->id))
 643                 return get_timer_reg(vcpu, reg);
 644
 645         return kvm_arm_sys_reg_get_reg(vcpu, reg);
 646 }
 647
 648 int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 649 {
 650         /* We currently use nothing arch-specific in upper 32 bits */
 651         if ((reg->id & ~KVM_REG_SIZE_MASK) >> 32 != KVM_REG_ARM64 >> 32)
 652                 return -EINVAL;
 653
 654         switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
 655         case KVM_REG_ARM_CORE:  return set_core_reg(vcpu, reg);
 656         case KVM_REG_ARM_FW:    return kvm_arm_set_fw_reg(vcpu, reg);
 657         case KVM_REG_ARM64_SVE: return set_sve_reg(vcpu, reg);
 658         default: break; /* fall through */
 659         }
 660
 661         if (is_timer_reg(reg->id))
 662                 return set_timer_reg(vcpu, reg);
 663
 664         return kvm_arm_sys_reg_set_reg(vcpu, reg);
 665 }
 666
 667 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 668                                   struct kvm_sregs *sregs)
 669 {
 670         return -EINVAL;
 671 }
 672
 673 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 674                                   struct kvm_sregs *sregs)
 675 {
 676         return -EINVAL;
 677 }
 678
 679 int __kvm_arm_vcpu_get_events(struct kvm_vcpu *vcpu,
 680                               struct kvm_vcpu_events *events)
 681 {
 682         events->exception.serror_pending = !!(vcpu->arch.hcr_el2 & HCR_VSE);
 683         events->exception.serror_has_esr = cpus_have_const_cap(ARM64_HAS_RAS_EXTN);
 684
 685         if (events->exception.serror_pending && events->exception.serror_has_esr)
 686                 events->exception.serror_esr = vcpu_get_vsesr(vcpu);
 687
 688         return 0;
 689 }
 690
 691 int __kvm_arm_vcpu_set_events(struct kvm_vcpu *vcpu,
 692                               struct kvm_vcpu_events *events)
 693 {
 694         bool serror_pending = events->exception.serror_pending;
 695         bool has_esr = events->exception.serror_has_esr;
 696
 697         if (serror_pending && has_esr) {
 698                 if (!cpus_have_const_cap(ARM64_HAS_RAS_EXTN))
 699                         return -EINVAL;
 700
 701                 if (!((events->exception.serror_esr) & ~ESR_ELx_ISS_MASK))
 702                         kvm_set_sei_esr(vcpu, events->exception.serror_esr);
 703                 else
 704                         return -EINVAL;
 705         } else if (serror_pending) {
 706                 kvm_inject_vabt(vcpu);
 707         }
 708
 709         return 0;
 710 }
 711
 712 int __attribute_const__ kvm_target_cpu(void)
 713 {
 714         unsigned long implementor = read_cpuid_implementor();
 715         unsigned long part_number = read_cpuid_part_number();
 716
 717         switch (implementor) {
 718         case ARM_CPU_IMP_ARM:
 719                 switch (part_number) {
 720                 case ARM_CPU_PART_AEM_V8:
 721                         return KVM_ARM_TARGET_AEM_V8;
 722                 case ARM_CPU_PART_FOUNDATION:
 723                         return KVM_ARM_TARGET_FOUNDATION_V8;
 724                 case ARM_CPU_PART_CORTEX_A53:
 725                         return KVM_ARM_TARGET_CORTEX_A53;
 726                 case ARM_CPU_PART_CORTEX_A57:
 727                         return KVM_ARM_TARGET_CORTEX_A57;
 728                 }
 729                 break;
 730         case ARM_CPU_IMP_APM:
 731                 switch (part_number) {
 732                 case APM_CPU_PART_POTENZA:
 733                         return KVM_ARM_TARGET_XGENE_POTENZA;
 734                 }
 735                 break;
 736         }
 737
 738         /* Return a default generic target */
 739         return KVM_ARM_TARGET_GENERIC_V8;
 740 }
 741
 742 int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init)
 743 {
 744         int target = kvm_target_cpu();
 745
 746         if (target < 0)
 747                 return -ENODEV;
 748
 749         memset(init, 0, sizeof(*init));
 750
 751         /*
 752          * For now, we don't return any features.
 753          * In future, we might use features to return target
 754          * specific features available for the preferred
 755          * target type.
 756          */
 757         init->target = (__u32)target;
 758
 759         return 0;
 760 }
 761
 762 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 763 {
 764         return -EINVAL;
 765 }
 766
 767 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 768 {
 769         return -EINVAL;
 770 }
 771
 772 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
 773                                   struct kvm_translation *tr)
 774 {
 775         return -EINVAL;
 776 }
 777
 778 #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE |    \
 779                             KVM_GUESTDBG_USE_SW_BP | \
 780                             KVM_GUESTDBG_USE_HW | \
 781                             KVM_GUESTDBG_SINGLESTEP)
 782
 783 /**
 784  * kvm_arch_vcpu_ioctl_set_guest_debug - set up guest debugging
 785  * @kvm:        pointer to the KVM struct
 786  * @kvm_guest_debug: the ioctl data buffer
 787  *
 788  * This sets up and enables the VM for guest debugging. Userspace
 789  * passes in a control flag to enable different debug types and
 790  * potentially other architecture specific information in the rest of
 791  * the structure.
 792  */
 793 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 794                                         struct kvm_guest_debug *dbg)
 795 {
 796         int ret = 0;
 797
 798         trace_kvm_set_guest_debug(vcpu, dbg->control);
 799
 800         if (dbg->control & ~KVM_GUESTDBG_VALID_MASK) {
 801                 ret = -EINVAL;
 802                 goto out;
 803         }
 804
 805         if (dbg->control & KVM_GUESTDBG_ENABLE) {
 806                 vcpu->guest_debug = dbg->control;
 807
 808                 /* Hardware assisted Break and Watch points */
 809                 if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) {
 810                         vcpu->arch.external_debug_state = dbg->arch;
 811                 }
 812
 813         } else {
 814                 /* If not enabled clear all flags */
 815                 vcpu->guest_debug = 0;
 816         }
 817
 818 out:
 819         return ret;
 820 }
 821
 822 int kvm_arm_vcpu_arch_set_attr(struct kvm_vcpu *vcpu,
 823                                struct kvm_device_attr *attr)
 824 {
 825         int ret;
 826
 827         switch (attr->group) {
 828         case KVM_ARM_VCPU_PMU_V3_CTRL:
 829                 ret = kvm_arm_pmu_v3_set_attr(vcpu, attr);
 830                 break;
 831         case KVM_ARM_VCPU_TIMER_CTRL:
 832                 ret = kvm_arm_timer_set_attr(vcpu, attr);
 833                 break;
 834         default:
 835                 ret = -ENXIO;
 836                 break;
 837         }
 838
 839         return ret;
 840 }
 841
 842 int kvm_arm_vcpu_arch_get_attr(struct kvm_vcpu *vcpu,
 843                                struct kvm_device_attr *attr)
 844 {
 845         int ret;
 846
 847         switch (attr->group) {
 848         case KVM_ARM_VCPU_PMU_V3_CTRL:
 849                 ret = kvm_arm_pmu_v3_get_attr(vcpu, attr);
 850                 break;
 851         case KVM_ARM_VCPU_TIMER_CTRL:
 852                 ret = kvm_arm_timer_get_attr(vcpu, attr);
 853                 break;
 854         default:
 855                 ret = -ENXIO;
 856                 break;
 857         }
 858
 859         return ret;
 860 }
 861
 862 int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu,
 863                                struct kvm_device_attr *attr)
 864 {
 865         int ret;
 866
 867         switch (attr->group) {
 868         case KVM_ARM_VCPU_PMU_V3_CTRL:
 869                 ret = kvm_arm_pmu_v3_has_attr(vcpu, attr);
 870                 break;
 871         case KVM_ARM_VCPU_TIMER_CTRL:
 872                 ret = kvm_arm_timer_has_attr(vcpu, attr);
 873                 break;
 874         default:
 875                 ret = -ENXIO;
 876                 break;
 877         }
 878
 879         return ret;
 880 }