target/arm/kvm64.c

   1 /*
   2  * ARM implementation of KVM hooks, 64 bit specific code
   3  *
   4  * Copyright Mian-M. Hamayun 2013, Virtual Open Systems
   5  * Copyright Alex Bennée 2014, Linaro
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   8  * See the COPYING file in the top-level directory.
   9  *
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include <sys/ioctl.h>
  14 #include <sys/ptrace.h>
  15
  16 #include <linux/elf.h>
  17 #include <linux/kvm.h>
  18
  19 #include "qemu-common.h"
  20 #include "cpu.h"
  21 #include "qemu/timer.h"
  22 #include "qemu/error-report.h"
  23 #include "qemu/host-utils.h"
  24 #include "qemu/main-loop.h"
  25 #include "exec/gdbstub.h"
  26 #include "sysemu/runstate.h"
  27 #include "sysemu/kvm.h"
  28 #include "sysemu/kvm_int.h"
  29 #include "kvm_arm.h"
  30 #include "internals.h"
  31 #include "hw/acpi/acpi.h"
  32 #include "hw/acpi/ghes.h"
  33 #include "hw/arm/virt.h"
  34
  35 static bool have_guest_debug;
  36
  37 /*
  38  * Although the ARM implementation of hardware assisted debugging
  39  * allows for different breakpoints per-core, the current GDB
  40  * interface treats them as a global pool of registers (which seems to
  41  * be the case for x86, ppc and s390). As a result we store one copy
  42  * of registers which is used for all active cores.
  43  *
  44  * Write access is serialised by virtue of the GDB protocol which
  45  * updates things. Read access (i.e. when the values are copied to the
  46  * vCPU) is also gated by GDB's run control.
  47  *
  48  * This is not unreasonable as most of the time debugging kernels you
  49  * never know which core will eventually execute your function.
  50  */
  51
  52 typedef struct {
  53     uint64_t bcr;
  54     uint64_t bvr;
  55 } HWBreakpoint;
  56
  57 /* The watchpoint registers can cover more area than the requested
  58  * watchpoint so we need to store the additional information
  59  * somewhere. We also need to supply a CPUWatchpoint to the GDB stub
  60  * when the watchpoint is hit.
  61  */
  62 typedef struct {
  63     uint64_t wcr;
  64     uint64_t wvr;
  65     CPUWatchpoint details;
  66 } HWWatchpoint;
  67
  68 /* Maximum and current break/watch point counts */
  69 int max_hw_bps, max_hw_wps;
  70 GArray *hw_breakpoints, *hw_watchpoints;
  71
  72 #define cur_hw_wps      (hw_watchpoints->len)
  73 #define cur_hw_bps      (hw_breakpoints->len)
  74 #define get_hw_bp(i)    (&g_array_index(hw_breakpoints, HWBreakpoint, i))
  75 #define get_hw_wp(i)    (&g_array_index(hw_watchpoints, HWWatchpoint, i))
  76
  77 /**
  78  * kvm_arm_init_debug() - check for guest debug capabilities
  79  * @cs: CPUState
  80  *
  81  * kvm_check_extension returns the number of debug registers we have
  82  * or 0 if we have none.
  83  *
  84  */
  85 static void kvm_arm_init_debug(CPUState *cs)
  86 {
  87     have_guest_debug = kvm_check_extension(cs->kvm_state,
  88                                            KVM_CAP_SET_GUEST_DEBUG);
  89
  90     max_hw_wps = kvm_check_extension(cs->kvm_state, KVM_CAP_GUEST_DEBUG_HW_WPS);
  91     hw_watchpoints = g_array_sized_new(true, true,
  92                                        sizeof(HWWatchpoint), max_hw_wps);
  93
  94     max_hw_bps = kvm_check_extension(cs->kvm_state, KVM_CAP_GUEST_DEBUG_HW_BPS);
  95     hw_breakpoints = g_array_sized_new(true, true,
  96                                        sizeof(HWBreakpoint), max_hw_bps);
  97     return;
  98 }
  99
 100 /**
 101  * insert_hw_breakpoint()
 102  * @addr: address of breakpoint
 103  *
 104  * See ARM ARM D2.9.1 for details but here we are only going to create
 105  * simple un-linked breakpoints (i.e. we don't chain breakpoints
 106  * together to match address and context or vmid). The hardware is
 107  * capable of fancier matching but that will require exposing that
 108  * fanciness to GDB's interface
 109  *
 110  * DBGBCR<n>_EL1, Debug Breakpoint Control Registers
 111  *
 112  *  31  24 23  20 19   16 15 14  13  12   9 8   5 4    3 2   1  0
 113  * +------+------+-------+-----+----+------+-----+------+-----+---+
 114  * | RES0 |  BT  |  LBN  | SSC | HMC| RES0 | BAS | RES0 | PMC | E |
 115  * +------+------+-------+-----+----+------+-----+------+-----+---+
 116  *
 117  * BT: Breakpoint type (0 = unlinked address match)
 118  * LBN: Linked BP number (0 = unused)
 119  * SSC/HMC/PMC: Security, Higher and Priv access control (Table D-12)
 120  * BAS: Byte Address Select (RES1 for AArch64)
 121  * E: Enable bit
 122  *
 123  * DBGBVR<n>_EL1, Debug Breakpoint Value Registers
 124  *
 125  *  63  53 52       49 48       2  1 0
 126  * +------+-----------+----------+-----+
 127  * | RESS | VA[52:49] | VA[48:2] | 0 0 |
 128  * +------+-----------+----------+-----+
 129  *
 130  * Depending on the addressing mode bits the top bits of the register
 131  * are a sign extension of the highest applicable VA bit. Some
 132  * versions of GDB don't do it correctly so we ensure they are correct
 133  * here so future PC comparisons will work properly.
 134  */
 135
 136 static int insert_hw_breakpoint(target_ulong addr)
 137 {
 138     HWBreakpoint brk = {
 139         .bcr = 0x1,                             /* BCR E=1, enable */
 140         .bvr = sextract64(addr, 0, 53)
 141     };
 142
 143     if (cur_hw_bps >= max_hw_bps) {
 144         return -ENOBUFS;
 145     }
 146
 147     brk.bcr = deposit32(brk.bcr, 1, 2, 0x3);   /* PMC = 11 */
 148     brk.bcr = deposit32(brk.bcr, 5, 4, 0xf);   /* BAS = RES1 */
 149
 150     g_array_append_val(hw_breakpoints, brk);
 151
 152     return 0;
 153 }
 154
 155 /**
 156  * delete_hw_breakpoint()
 157  * @pc: address of breakpoint
 158  *
 159  * Delete a breakpoint and shuffle any above down
 160  */
 161
 162 static int delete_hw_breakpoint(target_ulong pc)
 163 {
 164     int i;
 165     for (i = 0; i < hw_breakpoints->len; i++) {
 166         HWBreakpoint *brk = get_hw_bp(i);
 167         if (brk->bvr == pc) {
 168             g_array_remove_index(hw_breakpoints, i);
 169             return 0;
 170         }
 171     }
 172     return -ENOENT;
 173 }
 174
 175 /**
 176  * insert_hw_watchpoint()
 177  * @addr: address of watch point
 178  * @len: size of area
 179  * @type: type of watch point
 180  *
 181  * See ARM ARM D2.10. As with the breakpoints we can do some advanced
 182  * stuff if we want to. The watch points can be linked with the break
 183  * points above to make them context aware. However for simplicity
 184  * currently we only deal with simple read/write watch points.
 185  *
 186  * D7.3.11 DBGWCR<n>_EL1, Debug Watchpoint Control Registers
 187  *
 188  *  31  29 28   24 23  21  20  19 16 15 14  13   12  5 4   3 2   1  0
 189  * +------+-------+------+----+-----+-----+-----+-----+-----+-----+---+
 190  * | RES0 |  MASK | RES0 | WT | LBN | SSC | HMC | BAS | LSC | PAC | E |
 191  * +------+-------+------+----+-----+-----+-----+-----+-----+-----+---+
 192  *
 193  * MASK: num bits addr mask (0=none,01/10=res,11=3 bits (8 bytes))
 194  * WT: 0 - unlinked, 1 - linked (not currently used)
 195  * LBN: Linked BP number (not currently used)
 196  * SSC/HMC/PAC: Security, Higher and Priv access control (Table D2-11)
 197  * BAS: Byte Address Select
 198  * LSC: Load/Store control (01: load, 10: store, 11: both)
 199  * E: Enable
 200  *
 201  * The bottom 2 bits of the value register are masked. Therefore to
 202  * break on any sizes smaller than an unaligned word you need to set
 203  * MASK=0, BAS=bit per byte in question. For larger regions (^2) you
 204  * need to ensure you mask the address as required and set BAS=0xff
 205  */
 206
 207 static int insert_hw_watchpoint(target_ulong addr,
 208                                 target_ulong len, int type)
 209 {
 210     HWWatchpoint wp = {
 211         .wcr = 1, /* E=1, enable */
 212         .wvr = addr & (~0x7ULL),
 213         .details = { .vaddr = addr, .len = len }
 214     };
 215
 216     if (cur_hw_wps >= max_hw_wps) {
 217         return -ENOBUFS;
 218     }
 219
 220     /*
 221      * HMC=0 SSC=0 PAC=3 will hit EL0 or EL1, any security state,
 222      * valid whether EL3 is implemented or not
 223      */
 224     wp.wcr = deposit32(wp.wcr, 1, 2, 3);
 225
 226     switch (type) {
 227     case GDB_WATCHPOINT_READ:
 228         wp.wcr = deposit32(wp.wcr, 3, 2, 1);
 229         wp.details.flags = BP_MEM_READ;
 230         break;
 231     case GDB_WATCHPOINT_WRITE:
 232         wp.wcr = deposit32(wp.wcr, 3, 2, 2);
 233         wp.details.flags = BP_MEM_WRITE;
 234         break;
 235     case GDB_WATCHPOINT_ACCESS:
 236         wp.wcr = deposit32(wp.wcr, 3, 2, 3);
 237         wp.details.flags = BP_MEM_ACCESS;
 238         break;
 239     default:
 240         g_assert_not_reached();
 241         break;
 242     }
 243     if (len <= 8) {
 244         /* we align the address and set the bits in BAS */
 245         int off = addr & 0x7;
 246         int bas = (1 << len) - 1;
 247
 248         wp.wcr = deposit32(wp.wcr, 5 + off, 8 - off, bas);
 249     } else {
 250         /* For ranges above 8 bytes we need to be a power of 2 */
 251         if (is_power_of_2(len)) {
 252             int bits = ctz64(len);
 253
 254             wp.wvr &= ~((1 << bits) - 1);
 255             wp.wcr = deposit32(wp.wcr, 24, 4, bits);
 256             wp.wcr = deposit32(wp.wcr, 5, 8, 0xff);
 257         } else {
 258             return -ENOBUFS;
 259         }
 260     }
 261
 262     g_array_append_val(hw_watchpoints, wp);
 263     return 0;
 264 }
 265
 266
 267 static bool check_watchpoint_in_range(int i, target_ulong addr)
 268 {
 269     HWWatchpoint *wp = get_hw_wp(i);
 270     uint64_t addr_top, addr_bottom = wp->wvr;
 271     int bas = extract32(wp->wcr, 5, 8);
 272     int mask = extract32(wp->wcr, 24, 4);
 273
 274     if (mask) {
 275         addr_top = addr_bottom + (1 << mask);
 276     } else {
 277         /* BAS must be contiguous but can offset against the base
 278          * address in DBGWVR */
 279         addr_bottom = addr_bottom + ctz32(bas);
 280         addr_top = addr_bottom + clo32(bas);
 281     }
 282
 283     if (addr >= addr_bottom && addr <= addr_top) {
 284         return true;
 285     }
 286
 287     return false;
 288 }
 289
 290 /**
 291  * delete_hw_watchpoint()
 292  * @addr: address of breakpoint
 293  *
 294  * Delete a breakpoint and shuffle any above down
 295  */
 296
 297 static int delete_hw_watchpoint(target_ulong addr,
 298                                 target_ulong len, int type)
 299 {
 300     int i;
 301     for (i = 0; i < cur_hw_wps; i++) {
 302         if (check_watchpoint_in_range(i, addr)) {
 303             g_array_remove_index(hw_watchpoints, i);
 304             return 0;
 305         }
 306     }
 307     return -ENOENT;
 308 }
 309
 310
 311 int kvm_arch_insert_hw_breakpoint(target_ulong addr,
 312                                   target_ulong len, int type)
 313 {
 314     switch (type) {
 315     case GDB_BREAKPOINT_HW:
 316         return insert_hw_breakpoint(addr);
 317         break;
 318     case GDB_WATCHPOINT_READ:
 319     case GDB_WATCHPOINT_WRITE:
 320     case GDB_WATCHPOINT_ACCESS:
 321         return insert_hw_watchpoint(addr, len, type);
 322     default:
 323         return -ENOSYS;
 324     }
 325 }
 326
 327 int kvm_arch_remove_hw_breakpoint(target_ulong addr,
 328                                   target_ulong len, int type)
 329 {
 330     switch (type) {
 331     case GDB_BREAKPOINT_HW:
 332         return delete_hw_breakpoint(addr);
 333         break;
 334     case GDB_WATCHPOINT_READ:
 335     case GDB_WATCHPOINT_WRITE:
 336     case GDB_WATCHPOINT_ACCESS:
 337         return delete_hw_watchpoint(addr, len, type);
 338     default:
 339         return -ENOSYS;
 340     }
 341 }
 342
 343
 344 void kvm_arch_remove_all_hw_breakpoints(void)
 345 {
 346     if (cur_hw_wps > 0) {
 347         g_array_remove_range(hw_watchpoints, 0, cur_hw_wps);
 348     }
 349     if (cur_hw_bps > 0) {
 350         g_array_remove_range(hw_breakpoints, 0, cur_hw_bps);
 351     }
 352 }
 353
 354 void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr)
 355 {
 356     int i;
 357     memset(ptr, 0, sizeof(struct kvm_guest_debug_arch));
 358
 359     for (i = 0; i < max_hw_wps; i++) {
 360         HWWatchpoint *wp = get_hw_wp(i);
 361         ptr->dbg_wcr[i] = wp->wcr;
 362         ptr->dbg_wvr[i] = wp->wvr;
 363     }
 364     for (i = 0; i < max_hw_bps; i++) {
 365         HWBreakpoint *bp = get_hw_bp(i);
 366         ptr->dbg_bcr[i] = bp->bcr;
 367         ptr->dbg_bvr[i] = bp->bvr;
 368     }
 369 }
 370
 371 bool kvm_arm_hw_debug_active(CPUState *cs)
 372 {
 373     return ((cur_hw_wps > 0) || (cur_hw_bps > 0));
 374 }
 375
 376 static bool find_hw_breakpoint(CPUState *cpu, target_ulong pc)
 377 {
 378     int i;
 379
 380     for (i = 0; i < cur_hw_bps; i++) {
 381         HWBreakpoint *bp = get_hw_bp(i);
 382         if (bp->bvr == pc) {
 383             return true;
 384         }
 385     }
 386     return false;
 387 }
 388
 389 static CPUWatchpoint *find_hw_watchpoint(CPUState *cpu, target_ulong addr)
 390 {
 391     int i;
 392
 393     for (i = 0; i < cur_hw_wps; i++) {
 394         if (check_watchpoint_in_range(i, addr)) {
 395             return &get_hw_wp(i)->details;
 396         }
 397     }
 398     return NULL;
 399 }
 400
 401 static bool kvm_arm_pmu_set_attr(CPUState *cs, struct kvm_device_attr *attr)
 402 {
 403     int err;
 404
 405     err = kvm_vcpu_ioctl(cs, KVM_HAS_DEVICE_ATTR, attr);
 406     if (err != 0) {
 407         error_report("PMU: KVM_HAS_DEVICE_ATTR: %s", strerror(-err));
 408         return false;
 409     }
 410
 411     err = kvm_vcpu_ioctl(cs, KVM_SET_DEVICE_ATTR, attr);
 412     if (err != 0) {
 413         error_report("PMU: KVM_SET_DEVICE_ATTR: %s", strerror(-err));
 414         return false;
 415     }
 416
 417     return true;
 418 }
 419
 420 void kvm_arm_pmu_init(CPUState *cs)
 421 {
 422     struct kvm_device_attr attr = {
 423         .group = KVM_ARM_VCPU_PMU_V3_CTRL,
 424         .attr = KVM_ARM_VCPU_PMU_V3_INIT,
 425     };
 426
 427     if (!ARM_CPU(cs)->has_pmu) {
 428         return;
 429     }
 430     if (!kvm_arm_pmu_set_attr(cs, &attr)) {
 431         error_report("failed to init PMU");
 432         abort();
 433     }
 434 }
 435
 436 void kvm_arm_pmu_set_irq(CPUState *cs, int irq)
 437 {
 438     struct kvm_device_attr attr = {
 439         .group = KVM_ARM_VCPU_PMU_V3_CTRL,
 440         .addr = (intptr_t)&irq,
 441         .attr = KVM_ARM_VCPU_PMU_V3_IRQ,
 442     };
 443
 444     if (!ARM_CPU(cs)->has_pmu) {
 445         return;
 446     }
 447     if (!kvm_arm_pmu_set_attr(cs, &attr)) {
 448         error_report("failed to set irq for PMU");
 449         abort();
 450     }
 451 }
 452
 453 static int read_sys_reg32(int fd, uint32_t *pret, uint64_t id)
 454 {
 455     uint64_t ret;
 456     struct kvm_one_reg idreg = { .id = id, .addr = (uintptr_t)&ret };
 457     int err;
 458
 459     assert((id & KVM_REG_SIZE_MASK) == KVM_REG_SIZE_U64);
 460     err = ioctl(fd, KVM_GET_ONE_REG, &idreg);
 461     if (err < 0) {
 462         return -1;
 463     }
 464     *pret = ret;
 465     return 0;
 466 }
 467
 468 static int read_sys_reg64(int fd, uint64_t *pret, uint64_t id)
 469 {
 470     struct kvm_one_reg idreg = { .id = id, .addr = (uintptr_t)pret };
 471
 472     assert((id & KVM_REG_SIZE_MASK) == KVM_REG_SIZE_U64);
 473     return ioctl(fd, KVM_GET_ONE_REG, &idreg);
 474 }
 475
 476 bool kvm_arm_get_host_cpu_features(ARMHostCPUFeatures *ahcf)
 477 {
 478     /* Identify the feature bits corresponding to the host CPU, and
 479      * fill out the ARMHostCPUClass fields accordingly. To do this
 480      * we have to create a scratch VM, create a single CPU inside it,
 481      * and then query that CPU for the relevant ID registers.
 482      */
 483     int fdarray[3];
 484     bool sve_supported;
 485     uint64_t features = 0;
 486     uint64_t t;
 487     int err;
 488
 489     /* Old kernels may not know about the PREFERRED_TARGET ioctl: however
 490      * we know these will only support creating one kind of guest CPU,
 491      * which is its preferred CPU type. Fortunately these old kernels
 492      * support only a very limited number of CPUs.
 493      */
 494     static const uint32_t cpus_to_try[] = {
 495         KVM_ARM_TARGET_AEM_V8,
 496         KVM_ARM_TARGET_FOUNDATION_V8,
 497         KVM_ARM_TARGET_CORTEX_A57,
 498         QEMU_KVM_ARM_TARGET_NONE
 499     };
 500     /*
 501      * target = -1 informs kvm_arm_create_scratch_host_vcpu()
 502      * to use the preferred target
 503      */
 504     struct kvm_vcpu_init init = { .target = -1, };
 505
 506     if (!kvm_arm_create_scratch_host_vcpu(cpus_to_try, fdarray, &init)) {
 507         return false;
 508     }
 509
 510     ahcf->target = init.target;
 511     ahcf->dtb_compatible = "arm,arm-v8";
 512
 513     err = read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64pfr0,
 514                          ARM64_SYS_REG(3, 0, 0, 4, 0));
 515     if (unlikely(err < 0)) {
 516         /*
 517          * Before v4.15, the kernel only exposed a limited number of system
 518          * registers, not including any of the interesting AArch64 ID regs.
 519          * For the most part we could leave these fields as zero with minimal
 520          * effect, since this does not affect the values seen by the guest.
 521          *
 522          * However, it could cause problems down the line for QEMU,
 523          * so provide a minimal v8.0 default.
 524          *
 525          * ??? Could read MIDR and use knowledge from cpu64.c.
 526          * ??? Could map a page of memory into our temp guest and
 527          *     run the tiniest of hand-crafted kernels to extract
 528          *     the values seen by the guest.
 529          * ??? Either of these sounds like too much effort just
 530          *     to work around running a modern host kernel.
 531          */
 532         ahcf->isar.id_aa64pfr0 = 0x00000011; /* EL1&0, AArch64 only */
 533         err = 0;
 534     } else {
 535         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64pfr1,
 536                               ARM64_SYS_REG(3, 0, 0, 4, 1));
 537         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64dfr0,
 538                               ARM64_SYS_REG(3, 0, 0, 5, 0));
 539         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64dfr1,
 540                               ARM64_SYS_REG(3, 0, 0, 5, 1));
 541         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64isar0,
 542                               ARM64_SYS_REG(3, 0, 0, 6, 0));
 543         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64isar1,
 544                               ARM64_SYS_REG(3, 0, 0, 6, 1));
 545         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64mmfr0,
 546                               ARM64_SYS_REG(3, 0, 0, 7, 0));
 547         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64mmfr1,
 548                               ARM64_SYS_REG(3, 0, 0, 7, 1));
 549         err |= read_sys_reg64(fdarray[2], &ahcf->isar.id_aa64mmfr2,
 550                               ARM64_SYS_REG(3, 0, 0, 7, 2));
 551
 552         /*
 553          * Note that if AArch32 support is not present in the host,
 554          * the AArch32 sysregs are present to be read, but will
 555          * return UNKNOWN values.  This is neither better nor worse
 556          * than skipping the reads and leaving 0, as we must avoid
 557          * considering the values in every case.
 558          */
 559         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_dfr0,
 560                               ARM64_SYS_REG(3, 0, 0, 1, 2));
 561         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_mmfr0,
 562                               ARM64_SYS_REG(3, 0, 0, 1, 4));
 563         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_mmfr1,
 564                               ARM64_SYS_REG(3, 0, 0, 1, 5));
 565         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_mmfr2,
 566                               ARM64_SYS_REG(3, 0, 0, 1, 6));
 567         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_mmfr3,
 568                               ARM64_SYS_REG(3, 0, 0, 1, 7));
 569         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar0,
 570                               ARM64_SYS_REG(3, 0, 0, 2, 0));
 571         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar1,
 572                               ARM64_SYS_REG(3, 0, 0, 2, 1));
 573         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar2,
 574                               ARM64_SYS_REG(3, 0, 0, 2, 2));
 575         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar3,
 576                               ARM64_SYS_REG(3, 0, 0, 2, 3));
 577         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar4,
 578                               ARM64_SYS_REG(3, 0, 0, 2, 4));
 579         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar5,
 580                               ARM64_SYS_REG(3, 0, 0, 2, 5));
 581         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_mmfr4,
 582                               ARM64_SYS_REG(3, 0, 0, 2, 6));
 583         err |= read_sys_reg32(fdarray[2], &ahcf->isar.id_isar6,
 584                               ARM64_SYS_REG(3, 0, 0, 2, 7));
 585
 586         err |= read_sys_reg32(fdarray[2], &ahcf->isar.mvfr0,
 587                               ARM64_SYS_REG(3, 0, 0, 3, 0));
 588         err |= read_sys_reg32(fdarray[2], &ahcf->isar.mvfr1,
 589                               ARM64_SYS_REG(3, 0, 0, 3, 1));
 590         err |= read_sys_reg32(fdarray[2], &ahcf->isar.mvfr2,
 591                               ARM64_SYS_REG(3, 0, 0, 3, 2));
 592
 593         /*
 594          * DBGDIDR is a bit complicated because the kernel doesn't
 595          * provide an accessor for it in 64-bit mode, which is what this
 596          * scratch VM is in, and there's no architected "64-bit sysreg
 597          * which reads the same as the 32-bit register" the way there is
 598          * for other ID registers. Instead we synthesize a value from the
 599          * AArch64 ID_AA64DFR0, the same way the kernel code in
 600          * arch/arm64/kvm/sys_regs.c:trap_dbgidr() does.
 601          * We only do this if the CPU supports AArch32 at EL1.
 602          */
 603         if (FIELD_EX32(ahcf->isar.id_aa64pfr0, ID_AA64PFR0, EL1) >= 2) {
 604             int wrps = FIELD_EX64(ahcf->isar.id_aa64dfr0, ID_AA64DFR0, WRPS);
 605             int brps = FIELD_EX64(ahcf->isar.id_aa64dfr0, ID_AA64DFR0, BRPS);
 606             int ctx_cmps =
 607                 FIELD_EX64(ahcf->isar.id_aa64dfr0, ID_AA64DFR0, CTX_CMPS);
 608             int version = 6; /* ARMv8 debug architecture */
 609             bool has_el3 =
 610                 !!FIELD_EX32(ahcf->isar.id_aa64pfr0, ID_AA64PFR0, EL3);
 611             uint32_t dbgdidr = 0;
 612
 613             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, WRPS, wrps);
 614             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, BRPS, brps);
 615             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, CTX_CMPS, ctx_cmps);
 616             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, VERSION, version);
 617             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, NSUHD_IMP, has_el3);
 618             dbgdidr = FIELD_DP32(dbgdidr, DBGDIDR, SE_IMP, has_el3);
 619             dbgdidr |= (1 << 15); /* RES1 bit */
 620             ahcf->isar.dbgdidr = dbgdidr;
 621         }
 622     }
 623
 624     sve_supported = ioctl(fdarray[0], KVM_CHECK_EXTENSION, KVM_CAP_ARM_SVE) > 0;
 625
 626     kvm_arm_destroy_scratch_host_vcpu(fdarray);
 627
 628     if (err < 0) {
 629         return false;
 630     }
 631
 632     /* Add feature bits that can't appear until after VCPU init. */
 633     if (sve_supported) {
 634         t = ahcf->isar.id_aa64pfr0;
 635         t = FIELD_DP64(t, ID_AA64PFR0, SVE, 1);
 636         ahcf->isar.id_aa64pfr0 = t;
 637     }
 638
 639     /*
 640      * We can assume any KVM supporting CPU is at least a v8
 641      * with VFPv4+Neon; this in turn implies most of the other
 642      * feature bits.
 643      */
 644     features |= 1ULL << ARM_FEATURE_V8;
 645     features |= 1ULL << ARM_FEATURE_NEON;
 646     features |= 1ULL << ARM_FEATURE_AARCH64;
 647     features |= 1ULL << ARM_FEATURE_PMU;
 648     features |= 1ULL << ARM_FEATURE_GENERIC_TIMER;
 649
 650     ahcf->features = features;
 651
 652     return true;
 653 }
 654
 655 bool kvm_arm_aarch32_supported(CPUState *cpu)
 656 {
 657     KVMState *s = KVM_STATE(current_accel());
 658
 659     return kvm_check_extension(s, KVM_CAP_ARM_EL1_32BIT);
 660 }
 661
 662 bool kvm_arm_sve_supported(CPUState *cpu)
 663 {
 664     KVMState *s = KVM_STATE(current_accel());
 665
 666     return kvm_check_extension(s, KVM_CAP_ARM_SVE);
 667 }
 668
 669 QEMU_BUILD_BUG_ON(KVM_ARM64_SVE_VQ_MIN != 1);
 670
 671 void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map)
 672 {
 673     /* Only call this function if kvm_arm_sve_supported() returns true. */
 674     static uint64_t vls[KVM_ARM64_SVE_VLS_WORDS];
 675     static bool probed;
 676     uint32_t vq = 0;
 677     int i, j;
 678
 679     bitmap_clear(map, 0, ARM_MAX_VQ);
 680
 681     /*
 682      * KVM ensures all host CPUs support the same set of vector lengths.
 683      * So we only need to create the scratch VCPUs once and then cache
 684      * the results.
 685      */
 686     if (!probed) {
 687         struct kvm_vcpu_init init = {
 688             .target = -1,
 689             .features[0] = (1 << KVM_ARM_VCPU_SVE),
 690         };
 691         struct kvm_one_reg reg = {
 692             .id = KVM_REG_ARM64_SVE_VLS,
 693             .addr = (uint64_t)&vls[0],
 694         };
 695         int fdarray[3], ret;
 696
 697         probed = true;
 698
 699         if (!kvm_arm_create_scratch_host_vcpu(NULL, fdarray, &init)) {
 700             error_report("failed to create scratch VCPU with SVE enabled");
 701             abort();
 702         }
 703         ret = ioctl(fdarray[2], KVM_GET_ONE_REG, &reg);
 704         kvm_arm_destroy_scratch_host_vcpu(fdarray);
 705         if (ret) {
 706             error_report("failed to get KVM_REG_ARM64_SVE_VLS: %s",
 707                          strerror(errno));
 708             abort();
 709         }
 710
 711         for (i = KVM_ARM64_SVE_VLS_WORDS - 1; i >= 0; --i) {
 712             if (vls[i]) {
 713                 vq = 64 - clz64(vls[i]) + i * 64;
 714                 break;
 715             }
 716         }
 717         if (vq > ARM_MAX_VQ) {
 718             warn_report("KVM supports vector lengths larger than "
 719                         "QEMU can enable");
 720         }
 721     }
 722
 723     for (i = 0; i < KVM_ARM64_SVE_VLS_WORDS; ++i) {
 724         if (!vls[i]) {
 725             continue;
 726         }
 727         for (j = 1; j <= 64; ++j) {
 728             vq = j + i * 64;
 729             if (vq > ARM_MAX_VQ) {
 730                 return;
 731             }
 732             if (vls[i] & (1UL << (j - 1))) {
 733                 set_bit(vq - 1, map);
 734             }
 735         }
 736     }
 737 }
 738
 739 static int kvm_arm_sve_set_vls(CPUState *cs)
 740 {
 741     uint64_t vls[KVM_ARM64_SVE_VLS_WORDS] = {0};
 742     struct kvm_one_reg reg = {
 743         .id = KVM_REG_ARM64_SVE_VLS,
 744         .addr = (uint64_t)&vls[0],
 745     };
 746     ARMCPU *cpu = ARM_CPU(cs);
 747     uint32_t vq;
 748     int i, j;
 749
 750     assert(cpu->sve_max_vq <= KVM_ARM64_SVE_VQ_MAX);
 751
 752     for (vq = 1; vq <= cpu->sve_max_vq; ++vq) {
 753         if (test_bit(vq - 1, cpu->sve_vq_map)) {
 754             i = (vq - 1) / 64;
 755             j = (vq - 1) % 64;
 756             vls[i] |= 1UL << j;
 757         }
 758     }
 759
 760     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
 761 }
 762
 763 #define ARM_CPU_ID_MPIDR       3, 0, 0, 0, 5
 764
 765 int kvm_arch_init_vcpu(CPUState *cs)
 766 {
 767     int ret;
 768     uint64_t mpidr;
 769     ARMCPU *cpu = ARM_CPU(cs);
 770     CPUARMState *env = &cpu->env;
 771
 772     if (cpu->kvm_target == QEMU_KVM_ARM_TARGET_NONE ||
 773         !object_dynamic_cast(OBJECT(cpu), TYPE_AARCH64_CPU)) {
 774         error_report("KVM is not supported for this guest CPU type");
 775         return -EINVAL;
 776     }
 777
 778     qemu_add_vm_change_state_handler(kvm_arm_vm_state_change, cs);
 779
 780     /* Determine init features for this CPU */
 781     memset(cpu->kvm_init_features, 0, sizeof(cpu->kvm_init_features));
 782     if (cpu->start_powered_off) {
 783         cpu->kvm_init_features[0] |= 1 << KVM_ARM_VCPU_POWER_OFF;
 784     }
 785     if (kvm_check_extension(cs->kvm_state, KVM_CAP_ARM_PSCI_0_2)) {
 786         cpu->psci_version = 2;
 787         cpu->kvm_init_features[0] |= 1 << KVM_ARM_VCPU_PSCI_0_2;
 788     }
 789     if (!arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
 790         cpu->kvm_init_features[0] |= 1 << KVM_ARM_VCPU_EL1_32BIT;
 791     }
 792     if (!kvm_check_extension(cs->kvm_state, KVM_CAP_ARM_PMU_V3)) {
 793         cpu->has_pmu = false;
 794     }
 795     if (cpu->has_pmu) {
 796         cpu->kvm_init_features[0] |= 1 << KVM_ARM_VCPU_PMU_V3;
 797     } else {
 798         env->features &= ~(1ULL << ARM_FEATURE_PMU);
 799     }
 800     if (cpu_isar_feature(aa64_sve, cpu)) {
 801         assert(kvm_arm_sve_supported(cs));
 802         cpu->kvm_init_features[0] |= 1 << KVM_ARM_VCPU_SVE;
 803     }
 804
 805     /* Do KVM_ARM_VCPU_INIT ioctl */
 806     ret = kvm_arm_vcpu_init(cs);
 807     if (ret) {
 808         return ret;
 809     }
 810
 811     if (cpu_isar_feature(aa64_sve, cpu)) {
 812         ret = kvm_arm_sve_set_vls(cs);
 813         if (ret) {
 814             return ret;
 815         }
 816         ret = kvm_arm_vcpu_finalize(cs, KVM_ARM_VCPU_SVE);
 817         if (ret) {
 818             return ret;
 819         }
 820     }
 821
 822     /*
 823      * When KVM is in use, PSCI is emulated in-kernel and not by qemu.
 824      * Currently KVM has its own idea about MPIDR assignment, so we
 825      * override our defaults with what we get from KVM.
 826      */
 827     ret = kvm_get_one_reg(cs, ARM64_SYS_REG(ARM_CPU_ID_MPIDR), &mpidr);
 828     if (ret) {
 829         return ret;
 830     }
 831     cpu->mp_affinity = mpidr & ARM64_AFFINITY_MASK;
 832
 833     kvm_arm_init_debug(cs);
 834
 835     /* Check whether user space can specify guest syndrome value */
 836     kvm_arm_init_serror_injection(cs);
 837
 838     return kvm_arm_init_cpreg_list(cpu);
 839 }
 840
 841 int kvm_arch_destroy_vcpu(CPUState *cs)
 842 {
 843     return 0;
 844 }
 845
 846 bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx)
 847 {
 848     /* Return true if the regidx is a register we should synchronize
 849      * via the cpreg_tuples array (ie is not a core or sve reg that
 850      * we sync by hand in kvm_arch_get/put_registers())
 851      */
 852     switch (regidx & KVM_REG_ARM_COPROC_MASK) {
 853     case KVM_REG_ARM_CORE:
 854     case KVM_REG_ARM64_SVE:
 855         return false;
 856     default:
 857         return true;
 858     }
 859 }
 860
 861 typedef struct CPRegStateLevel {
 862     uint64_t regidx;
 863     int level;
 864 } CPRegStateLevel;
 865
 866 /* All system registers not listed in the following table are assumed to be
 867  * of the level KVM_PUT_RUNTIME_STATE. If a register should be written less
 868  * often, you must add it to this table with a state of either
 869  * KVM_PUT_RESET_STATE or KVM_PUT_FULL_STATE.
 870  */
 871 static const CPRegStateLevel non_runtime_cpregs[] = {
 872     { KVM_REG_ARM_TIMER_CNT, KVM_PUT_FULL_STATE },
 873 };
 874
 875 int kvm_arm_cpreg_level(uint64_t regidx)
 876 {
 877     int i;
 878
 879     for (i = 0; i < ARRAY_SIZE(non_runtime_cpregs); i++) {
 880         const CPRegStateLevel *l = &non_runtime_cpregs[i];
 881         if (l->regidx == regidx) {
 882             return l->level;
 883         }
 884     }
 885
 886     return KVM_PUT_RUNTIME_STATE;
 887 }
 888
 889 /* Callers must hold the iothread mutex lock */
 890 static void kvm_inject_arm_sea(CPUState *c)
 891 {
 892     ARMCPU *cpu = ARM_CPU(c);
 893     CPUARMState *env = &cpu->env;
 894     CPUClass *cc = CPU_GET_CLASS(c);
 895     uint32_t esr;
 896     bool same_el;
 897
 898     c->exception_index = EXCP_DATA_ABORT;
 899     env->exception.target_el = 1;
 900
 901     /*
 902      * Set the DFSC to synchronous external abort and set FnV to not valid,
 903      * this will tell guest the FAR_ELx is UNKNOWN for this abort.
 904      */
 905     same_el = arm_current_el(env) == env->exception.target_el;
 906     esr = syn_data_abort_no_iss(same_el, 1, 0, 0, 0, 0, 0x10);
 907
 908     env->exception.syndrome = esr;
 909
 910     cc->do_interrupt(c);
 911 }
 912
 913 #define AARCH64_CORE_REG(x)   (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \
 914                  KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(x))
 915
 916 #define AARCH64_SIMD_CORE_REG(x)   (KVM_REG_ARM64 | KVM_REG_SIZE_U128 | \
 917                  KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(x))
 918
 919 #define AARCH64_SIMD_CTRL_REG(x)   (KVM_REG_ARM64 | KVM_REG_SIZE_U32 | \
 920                  KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(x))
 921
 922 static int kvm_arch_put_fpsimd(CPUState *cs)
 923 {
 924     CPUARMState *env = &ARM_CPU(cs)->env;
 925     struct kvm_one_reg reg;
 926     int i, ret;
 927
 928     for (i = 0; i < 32; i++) {
 929         uint64_t *q = aa64_vfp_qreg(env, i);
 930 #ifdef HOST_WORDS_BIGENDIAN
 931         uint64_t fp_val[2] = { q[1], q[0] };
 932         reg.addr = (uintptr_t)fp_val;
 933 #else
 934         reg.addr = (uintptr_t)q;
 935 #endif
 936         reg.id = AARCH64_SIMD_CORE_REG(fp_regs.vregs[i]);
 937         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
 938         if (ret) {
 939             return ret;
 940         }
 941     }
 942
 943     return 0;
 944 }
 945
 946 /*
 947  * KVM SVE registers come in slices where ZREGs have a slice size of 2048 bits
 948  * and PREGS and the FFR have a slice size of 256 bits. However we simply hard
 949  * code the slice index to zero for now as it's unlikely we'll need more than
 950  * one slice for quite some time.
 951  */
 952 static int kvm_arch_put_sve(CPUState *cs)
 953 {
 954     ARMCPU *cpu = ARM_CPU(cs);
 955     CPUARMState *env = &cpu->env;
 956     uint64_t tmp[ARM_MAX_VQ * 2];
 957     uint64_t *r;
 958     struct kvm_one_reg reg;
 959     int n, ret;
 960
 961     for (n = 0; n < KVM_ARM64_SVE_NUM_ZREGS; ++n) {
 962         r = sve_bswap64(tmp, &env->vfp.zregs[n].d[0], cpu->sve_max_vq * 2);
 963         reg.addr = (uintptr_t)r;
 964         reg.id = KVM_REG_ARM64_SVE_ZREG(n, 0);
 965         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
 966         if (ret) {
 967             return ret;
 968         }
 969     }
 970
 971     for (n = 0; n < KVM_ARM64_SVE_NUM_PREGS; ++n) {
 972         r = sve_bswap64(tmp, r = &env->vfp.pregs[n].p[0],
 973                         DIV_ROUND_UP(cpu->sve_max_vq * 2, 8));
 974         reg.addr = (uintptr_t)r;
 975         reg.id = KVM_REG_ARM64_SVE_PREG(n, 0);
 976         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
 977         if (ret) {
 978             return ret;
 979         }
 980     }
 981
 982     r = sve_bswap64(tmp, &env->vfp.pregs[FFR_PRED_NUM].p[0],
 983                     DIV_ROUND_UP(cpu->sve_max_vq * 2, 8));
 984     reg.addr = (uintptr_t)r;
 985     reg.id = KVM_REG_ARM64_SVE_FFR(0);
 986     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
 987     if (ret) {
 988         return ret;
 989     }
 990
 991     return 0;
 992 }
 993
 994 int kvm_arch_put_registers(CPUState *cs, int level)
 995 {
 996     struct kvm_one_reg reg;
 997     uint64_t val;
 998     uint32_t fpr;
 999     int i, ret;
1000     unsigned int el;
1001
1002     ARMCPU *cpu = ARM_CPU(cs);
1003     CPUARMState *env = &cpu->env;
1004
1005     /* If we are in AArch32 mode then we need to copy the AArch32 regs to the
1006      * AArch64 registers before pushing them out to 64-bit KVM.
1007      */
1008     if (!is_a64(env)) {
1009         aarch64_sync_32_to_64(env);
1010     }
1011
1012     for (i = 0; i < 31; i++) {
1013         reg.id = AARCH64_CORE_REG(regs.regs[i]);
1014         reg.addr = (uintptr_t) &env->xregs[i];
1015         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1016         if (ret) {
1017             return ret;
1018         }
1019     }
1020
1021     /* KVM puts SP_EL0 in regs.sp and SP_EL1 in regs.sp_el1. On the
1022      * QEMU side we keep the current SP in xregs[31] as well.
1023      */
1024     aarch64_save_sp(env, 1);
1025
1026     reg.id = AARCH64_CORE_REG(regs.sp);
1027     reg.addr = (uintptr_t) &env->sp_el[0];
1028     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1029     if (ret) {
1030         return ret;
1031     }
1032
1033     reg.id = AARCH64_CORE_REG(sp_el1);
1034     reg.addr = (uintptr_t) &env->sp_el[1];
1035     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1036     if (ret) {
1037         return ret;
1038     }
1039
1040     /* Note that KVM thinks pstate is 64 bit but we use a uint32_t */
1041     if (is_a64(env)) {
1042         val = pstate_read(env);
1043     } else {
1044         val = cpsr_read(env);
1045     }
1046     reg.id = AARCH64_CORE_REG(regs.pstate);
1047     reg.addr = (uintptr_t) &val;
1048     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1049     if (ret) {
1050         return ret;
1051     }
1052
1053     reg.id = AARCH64_CORE_REG(regs.pc);
1054     reg.addr = (uintptr_t) &env->pc;
1055     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1056     if (ret) {
1057         return ret;
1058     }
1059
1060     reg.id = AARCH64_CORE_REG(elr_el1);
1061     reg.addr = (uintptr_t) &env->elr_el[1];
1062     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1063     if (ret) {
1064         return ret;
1065     }
1066
1067     /* Saved Program State Registers
1068      *
1069      * Before we restore from the banked_spsr[] array we need to
1070      * ensure that any modifications to env->spsr are correctly
1071      * reflected in the banks.
1072      */
1073     el = arm_current_el(env);
1074     if (el > 0 && !is_a64(env)) {
1075         i = bank_number(env->uncached_cpsr & CPSR_M);
1076         env->banked_spsr[i] = env->spsr;
1077     }
1078
1079     /* KVM 0-4 map to QEMU banks 1-5 */
1080     for (i = 0; i < KVM_NR_SPSR; i++) {
1081         reg.id = AARCH64_CORE_REG(spsr[i]);
1082         reg.addr = (uintptr_t) &env->banked_spsr[i + 1];
1083         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1084         if (ret) {
1085             return ret;
1086         }
1087     }
1088
1089     if (cpu_isar_feature(aa64_sve, cpu)) {
1090         ret = kvm_arch_put_sve(cs);
1091     } else {
1092         ret = kvm_arch_put_fpsimd(cs);
1093     }
1094     if (ret) {
1095         return ret;
1096     }
1097
1098     reg.addr = (uintptr_t)(&fpr);
1099     fpr = vfp_get_fpsr(env);
1100     reg.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpsr);
1101     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1102     if (ret) {
1103         return ret;
1104     }
1105
1106     reg.addr = (uintptr_t)(&fpr);
1107     fpr = vfp_get_fpcr(env);
1108     reg.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpcr);
1109     ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
1110     if (ret) {
1111         return ret;
1112     }
1113
1114     write_cpustate_to_list(cpu, true);
1115
1116     if (!write_list_to_kvmstate(cpu, level)) {
1117         return -EINVAL;
1118     }
1119
1120    /*
1121     * Setting VCPU events should be triggered after syncing the registers
1122     * to avoid overwriting potential changes made by KVM upon calling
1123     * KVM_SET_VCPU_EVENTS ioctl
1124     */
1125     ret = kvm_put_vcpu_events(cpu);
1126     if (ret) {
1127         return ret;
1128     }
1129
1130     kvm_arm_sync_mpstate_to_kvm(cpu);
1131
1132     return ret;
1133 }
1134
1135 static int kvm_arch_get_fpsimd(CPUState *cs)
1136 {
1137     CPUARMState *env = &ARM_CPU(cs)->env;
1138     struct kvm_one_reg reg;
1139     int i, ret;
1140
1141     for (i = 0; i < 32; i++) {
1142         uint64_t *q = aa64_vfp_qreg(env, i);
1143         reg.id = AARCH64_SIMD_CORE_REG(fp_regs.vregs[i]);
1144         reg.addr = (uintptr_t)q;
1145         ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1146         if (ret) {
1147             return ret;
1148         } else {
1149 #ifdef HOST_WORDS_BIGENDIAN
1150             uint64_t t;
1151             t = q[0], q[0] = q[1], q[1] = t;
1152 #endif
1153         }
1154     }
1155
1156     return 0;
1157 }
1158
1159 /*
1160  * KVM SVE registers come in slices where ZREGs have a slice size of 2048 bits
1161  * and PREGS and the FFR have a slice size of 256 bits. However we simply hard
1162  * code the slice index to zero for now as it's unlikely we'll need more than
1163  * one slice for quite some time.
1164  */
1165 static int kvm_arch_get_sve(CPUState *cs)
1166 {
1167     ARMCPU *cpu = ARM_CPU(cs);
1168     CPUARMState *env = &cpu->env;
1169     struct kvm_one_reg reg;
1170     uint64_t *r;
1171     int n, ret;
1172
1173     for (n = 0; n < KVM_ARM64_SVE_NUM_ZREGS; ++n) {
1174         r = &env->vfp.zregs[n].d[0];
1175         reg.addr = (uintptr_t)r;
1176         reg.id = KVM_REG_ARM64_SVE_ZREG(n, 0);
1177         ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1178         if (ret) {
1179             return ret;
1180         }
1181         sve_bswap64(r, r, cpu->sve_max_vq * 2);
1182     }
1183
1184     for (n = 0; n < KVM_ARM64_SVE_NUM_PREGS; ++n) {
1185         r = &env->vfp.pregs[n].p[0];
1186         reg.addr = (uintptr_t)r;
1187         reg.id = KVM_REG_ARM64_SVE_PREG(n, 0);
1188         ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1189         if (ret) {
1190             return ret;
1191         }
1192         sve_bswap64(r, r, DIV_ROUND_UP(cpu->sve_max_vq * 2, 8));
1193     }
1194
1195     r = &env->vfp.pregs[FFR_PRED_NUM].p[0];
1196     reg.addr = (uintptr_t)r;
1197     reg.id = KVM_REG_ARM64_SVE_FFR(0);
1198     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1199     if (ret) {
1200         return ret;
1201     }
1202     sve_bswap64(r, r, DIV_ROUND_UP(cpu->sve_max_vq * 2, 8));
1203
1204     return 0;
1205 }
1206
1207 int kvm_arch_get_registers(CPUState *cs)
1208 {
1209     struct kvm_one_reg reg;
1210     uint64_t val;
1211     unsigned int el;
1212     uint32_t fpr;
1213     int i, ret;
1214
1215     ARMCPU *cpu = ARM_CPU(cs);
1216     CPUARMState *env = &cpu->env;
1217
1218     for (i = 0; i < 31; i++) {
1219         reg.id = AARCH64_CORE_REG(regs.regs[i]);
1220         reg.addr = (uintptr_t) &env->xregs[i];
1221         ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1222         if (ret) {
1223             return ret;
1224         }
1225     }
1226
1227     reg.id = AARCH64_CORE_REG(regs.sp);
1228     reg.addr = (uintptr_t) &env->sp_el[0];
1229     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1230     if (ret) {
1231         return ret;
1232     }
1233
1234     reg.id = AARCH64_CORE_REG(sp_el1);
1235     reg.addr = (uintptr_t) &env->sp_el[1];
1236     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1237     if (ret) {
1238         return ret;
1239     }
1240
1241     reg.id = AARCH64_CORE_REG(regs.pstate);
1242     reg.addr = (uintptr_t) &val;
1243     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1244     if (ret) {
1245         return ret;
1246     }
1247
1248     env->aarch64 = ((val & PSTATE_nRW) == 0);
1249     if (is_a64(env)) {
1250         pstate_write(env, val);
1251     } else {
1252         cpsr_write(env, val, 0xffffffff, CPSRWriteRaw);
1253     }
1254
1255     /* KVM puts SP_EL0 in regs.sp and SP_EL1 in regs.sp_el1. On the
1256      * QEMU side we keep the current SP in xregs[31] as well.
1257      */
1258     aarch64_restore_sp(env, 1);
1259
1260     reg.id = AARCH64_CORE_REG(regs.pc);
1261     reg.addr = (uintptr_t) &env->pc;
1262     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1263     if (ret) {
1264         return ret;
1265     }
1266
1267     /* If we are in AArch32 mode then we need to sync the AArch32 regs with the
1268      * incoming AArch64 regs received from 64-bit KVM.
1269      * We must perform this after all of the registers have been acquired from
1270      * the kernel.
1271      */
1272     if (!is_a64(env)) {
1273         aarch64_sync_64_to_32(env);
1274     }
1275
1276     reg.id = AARCH64_CORE_REG(elr_el1);
1277     reg.addr = (uintptr_t) &env->elr_el[1];
1278     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1279     if (ret) {
1280         return ret;
1281     }
1282
1283     /* Fetch the SPSR registers
1284      *
1285      * KVM SPSRs 0-4 map to QEMU banks 1-5
1286      */
1287     for (i = 0; i < KVM_NR_SPSR; i++) {
1288         reg.id = AARCH64_CORE_REG(spsr[i]);
1289         reg.addr = (uintptr_t) &env->banked_spsr[i + 1];
1290         ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1291         if (ret) {
1292             return ret;
1293         }
1294     }
1295
1296     el = arm_current_el(env);
1297     if (el > 0 && !is_a64(env)) {
1298         i = bank_number(env->uncached_cpsr & CPSR_M);
1299         env->spsr = env->banked_spsr[i];
1300     }
1301
1302     if (cpu_isar_feature(aa64_sve, cpu)) {
1303         ret = kvm_arch_get_sve(cs);
1304     } else {
1305         ret = kvm_arch_get_fpsimd(cs);
1306     }
1307     if (ret) {
1308         return ret;
1309     }
1310
1311     reg.addr = (uintptr_t)(&fpr);
1312     reg.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpsr);
1313     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1314     if (ret) {
1315         return ret;
1316     }
1317     vfp_set_fpsr(env, fpr);
1318
1319     reg.addr = (uintptr_t)(&fpr);
1320     reg.id = AARCH64_SIMD_CTRL_REG(fp_regs.fpcr);
1321     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
1322     if (ret) {
1323         return ret;
1324     }
1325     vfp_set_fpcr(env, fpr);
1326
1327     ret = kvm_get_vcpu_events(cpu);
1328     if (ret) {
1329         return ret;
1330     }
1331
1332     if (!write_kvmstate_to_list(cpu)) {
1333         return -EINVAL;
1334     }
1335     /* Note that it's OK to have registers which aren't in CPUState,
1336      * so we can ignore a failure return here.
1337      */
1338     write_list_to_cpustate(cpu);
1339
1340     kvm_arm_sync_mpstate_to_qemu(cpu);
1341
1342     /* TODO: other registers */
1343     return ret;
1344 }
1345
1346 void kvm_arch_on_sigbus_vcpu(CPUState *c, int code, void *addr)
1347 {
1348     ram_addr_t ram_addr;
1349     hwaddr paddr;
1350     Object *obj = qdev_get_machine();
1351     VirtMachineState *vms = VIRT_MACHINE(obj);
1352     bool acpi_enabled = virt_is_acpi_enabled(vms);
1353
1354     assert(code == BUS_MCEERR_AR || code == BUS_MCEERR_AO);
1355
1356     if (acpi_enabled && addr &&
1357             object_property_get_bool(obj, "ras", NULL)) {
1358         ram_addr = qemu_ram_addr_from_host(addr);
1359         if (ram_addr != RAM_ADDR_INVALID &&
1360             kvm_physical_memory_addr_from_host(c->kvm_state, addr, &paddr)) {
1361             kvm_hwpoison_page_add(ram_addr);
1362             /*
1363              * If this is a BUS_MCEERR_AR, we know we have been called
1364              * synchronously from the vCPU thread, so we can easily
1365              * synchronize the state and inject an error.
1366              *
1367              * TODO: we currently don't tell the guest at all about
1368              * BUS_MCEERR_AO. In that case we might either be being
1369              * called synchronously from the vCPU thread, or a bit
1370              * later from the main thread, so doing the injection of
1371              * the error would be more complicated.
1372              */
1373             if (code == BUS_MCEERR_AR) {
1374                 kvm_cpu_synchronize_state(c);
1375                 if (!acpi_ghes_record_errors(ACPI_HEST_SRC_ID_SEA, paddr)) {
1376                     kvm_inject_arm_sea(c);
1377                 } else {
1378                     error_report("failed to record the error");
1379                     abort();
1380                 }
1381             }
1382             return;
1383         }
1384         if (code == BUS_MCEERR_AO) {
1385             error_report("Hardware memory error at addr %p for memory used by "
1386                 "QEMU itself instead of guest system!", addr);
1387         }
1388     }
1389
1390     if (code == BUS_MCEERR_AR) {
1391         error_report("Hardware memory error!");
1392         exit(1);
1393     }
1394 }
1395
1396 /* C6.6.29 BRK instruction */
1397 static const uint32_t brk_insn = 0xd4200000;
1398
1399 int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
1400 {
1401     if (have_guest_debug) {
1402         if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 4, 0) ||
1403             cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&brk_insn, 4, 1)) {
1404             return -EINVAL;
1405         }
1406         return 0;
1407     } else {
1408         error_report("guest debug not supported on this kernel");
1409         return -EINVAL;
1410     }
1411 }
1412
1413 int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
1414 {
1415     static uint32_t brk;
1416
1417     if (have_guest_debug) {
1418         if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&brk, 4, 0) ||
1419             brk != brk_insn ||
1420             cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 4, 1)) {
1421             return -EINVAL;
1422         }
1423         return 0;
1424     } else {
1425         error_report("guest debug not supported on this kernel");
1426         return -EINVAL;
1427     }
1428 }
1429
1430 /* See v8 ARM ARM D7.2.27 ESR_ELx, Exception Syndrome Register
1431  *
1432  * To minimise translating between kernel and user-space the kernel
1433  * ABI just provides user-space with the full exception syndrome
1434  * register value to be decoded in QEMU.
1435  */
1436
1437 bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit)
1438 {
1439     int hsr_ec = syn_get_ec(debug_exit->hsr);
1440     ARMCPU *cpu = ARM_CPU(cs);
1441     CPUClass *cc = CPU_GET_CLASS(cs);
1442     CPUARMState *env = &cpu->env;
1443
1444     /* Ensure PC is synchronised */
1445     kvm_cpu_synchronize_state(cs);
1446
1447     switch (hsr_ec) {
1448     case EC_SOFTWARESTEP:
1449         if (cs->singlestep_enabled) {
1450             return true;
1451         } else {
1452             /*
1453              * The kernel should have suppressed the guest's ability to
1454              * single step at this point so something has gone wrong.
1455              */
1456             error_report("%s: guest single-step while debugging unsupported"
1457                          " (%"PRIx64", %"PRIx32")",
1458                          __func__, env->pc, debug_exit->hsr);
1459             return false;
1460         }
1461         break;
1462     case EC_AA64_BKPT:
1463         if (kvm_find_sw_breakpoint(cs, env->pc)) {
1464             return true;
1465         }
1466         break;
1467     case EC_BREAKPOINT:
1468         if (find_hw_breakpoint(cs, env->pc)) {
1469             return true;
1470         }
1471         break;
1472     case EC_WATCHPOINT:
1473     {
1474         CPUWatchpoint *wp = find_hw_watchpoint(cs, debug_exit->far);
1475         if (wp) {
1476             cs->watchpoint_hit = wp;
1477             return true;
1478         }
1479         break;
1480     }
1481     default:
1482         error_report("%s: unhandled debug exit (%"PRIx32", %"PRIx64")",
1483                      __func__, debug_exit->hsr, env->pc);
1484     }
1485
1486     /* If we are not handling the debug exception it must belong to
1487      * the guest. Let's re-use the existing TCG interrupt code to set
1488      * everything up properly.
1489      */
1490     cs->exception_index = EXCP_BKPT;
1491     env->exception.syndrome = debug_exit->hsr;
1492     env->exception.vaddress = debug_exit->far;
1493     env->exception.target_el = 1;
1494     qemu_mutex_lock_iothread();
1495     cc->do_interrupt(cs);
1496     qemu_mutex_unlock_iothread();
1497
1498     return false;
1499 }