target-mips/kvm.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * KVM/MIPS: MIPS specific KVM APIs
   7  *
   8  * Copyright (C) 2012-2014 Imagination Technologies Ltd.
   9  * Authors: Sanjay Lal <sanjayl@kymasys.com>
  10 */
  11
  12 #include "qemu/osdep.h"
  13 #include <sys/ioctl.h>
  14
  15 #include <linux/kvm.h>
  16
  17 #include "qemu-common.h"
  18 #include "cpu.h"
  19 #include "qemu/error-report.h"
  20 #include "qemu/timer.h"
  21 #include "sysemu/sysemu.h"
  22 #include "sysemu/kvm.h"
  23 #include "sysemu/cpus.h"
  24 #include "kvm_mips.h"
  25 #include "exec/memattrs.h"
  26
  27 #define DEBUG_KVM 0
  28
  29 #define DPRINTF(fmt, ...) \
  30     do { if (DEBUG_KVM) { fprintf(stderr, fmt, ## __VA_ARGS__); } } while (0)
  31
  32 static int kvm_mips_fpu_cap;
  33 static int kvm_mips_msa_cap;
  34
  35 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
  36     KVM_CAP_LAST_INFO
  37 };
  38
  39 static void kvm_mips_update_state(void *opaque, int running, RunState state);
  40
  41 unsigned long kvm_arch_vcpu_id(CPUState *cs)
  42 {
  43     return cs->cpu_index;
  44 }
  45
  46 int kvm_arch_init(MachineState *ms, KVMState *s)
  47 {
  48     /* MIPS has 128 signals */
  49     kvm_set_sigmask_len(s, 16);
  50
  51     kvm_mips_fpu_cap = kvm_check_extension(s, KVM_CAP_MIPS_FPU);
  52     kvm_mips_msa_cap = kvm_check_extension(s, KVM_CAP_MIPS_MSA);
  53
  54     DPRINTF("%s\n", __func__);
  55     return 0;
  56 }
  57
  58 int kvm_arch_init_vcpu(CPUState *cs)
  59 {
  60     MIPSCPU *cpu = MIPS_CPU(cs);
  61     CPUMIPSState *env = &cpu->env;
  62     int ret = 0;
  63
  64     qemu_add_vm_change_state_handler(kvm_mips_update_state, cs);
  65
  66     if (kvm_mips_fpu_cap && env->CP0_Config1 & (1 << CP0C1_FP)) {
  67         ret = kvm_vcpu_enable_cap(cs, KVM_CAP_MIPS_FPU, 0, 0);
  68         if (ret < 0) {
  69             /* mark unsupported so it gets disabled on reset */
  70             kvm_mips_fpu_cap = 0;
  71             ret = 0;
  72         }
  73     }
  74
  75     if (kvm_mips_msa_cap && env->CP0_Config3 & (1 << CP0C3_MSAP)) {
  76         ret = kvm_vcpu_enable_cap(cs, KVM_CAP_MIPS_MSA, 0, 0);
  77         if (ret < 0) {
  78             /* mark unsupported so it gets disabled on reset */
  79             kvm_mips_msa_cap = 0;
  80             ret = 0;
  81         }
  82     }
  83
  84     DPRINTF("%s\n", __func__);
  85     return ret;
  86 }
  87
  88 void kvm_mips_reset_vcpu(MIPSCPU *cpu)
  89 {
  90     CPUMIPSState *env = &cpu->env;
  91
  92     if (!kvm_mips_fpu_cap && env->CP0_Config1 & (1 << CP0C1_FP)) {
  93         fprintf(stderr, "Warning: KVM does not support FPU, disabling\n");
  94         env->CP0_Config1 &= ~(1 << CP0C1_FP);
  95     }
  96     if (!kvm_mips_msa_cap && env->CP0_Config3 & (1 << CP0C3_MSAP)) {
  97         fprintf(stderr, "Warning: KVM does not support MSA, disabling\n");
  98         env->CP0_Config3 &= ~(1 << CP0C3_MSAP);
  99     }
 100
 101     DPRINTF("%s\n", __func__);
 102 }
 103
 104 int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
 105 {
 106     DPRINTF("%s\n", __func__);
 107     return 0;
 108 }
 109
 110 int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
 111 {
 112     DPRINTF("%s\n", __func__);
 113     return 0;
 114 }
 115
 116 static inline int cpu_mips_io_interrupts_pending(MIPSCPU *cpu)
 117 {
 118     CPUMIPSState *env = &cpu->env;
 119
 120     return env->CP0_Cause & (0x1 << (2 + CP0Ca_IP));
 121 }
 122
 123
 124 void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
 125 {
 126     MIPSCPU *cpu = MIPS_CPU(cs);
 127     int r;
 128     struct kvm_mips_interrupt intr;
 129
 130     qemu_mutex_lock_iothread();
 131
 132     if ((cs->interrupt_request & CPU_INTERRUPT_HARD) &&
 133             cpu_mips_io_interrupts_pending(cpu)) {
 134         intr.cpu = -1;
 135         intr.irq = 2;
 136         r = kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
 137         if (r < 0) {
 138             error_report("%s: cpu %d: failed to inject IRQ %x",
 139                          __func__, cs->cpu_index, intr.irq);
 140         }
 141     }
 142
 143     qemu_mutex_unlock_iothread();
 144 }
 145
 146 MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)
 147 {
 148     return MEMTXATTRS_UNSPECIFIED;
 149 }
 150
 151 int kvm_arch_process_async_events(CPUState *cs)
 152 {
 153     return cs->halted;
 154 }
 155
 156 int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
 157 {
 158     int ret;
 159
 160     DPRINTF("%s\n", __func__);
 161     switch (run->exit_reason) {
 162     default:
 163         error_report("%s: unknown exit reason %d",
 164                      __func__, run->exit_reason);
 165         ret = -1;
 166         break;
 167     }
 168
 169     return ret;
 170 }
 171
 172 bool kvm_arch_stop_on_emulation_error(CPUState *cs)
 173 {
 174     DPRINTF("%s\n", __func__);
 175     return true;
 176 }
 177
 178 int kvm_arch_on_sigbus_vcpu(CPUState *cs, int code, void *addr)
 179 {
 180     DPRINTF("%s\n", __func__);
 181     return 1;
 182 }
 183
 184 int kvm_arch_on_sigbus(int code, void *addr)
 185 {
 186     DPRINTF("%s\n", __func__);
 187     return 1;
 188 }
 189
 190 void kvm_arch_init_irq_routing(KVMState *s)
 191 {
 192 }
 193
 194 int kvm_mips_set_interrupt(MIPSCPU *cpu, int irq, int level)
 195 {
 196     CPUState *cs = CPU(cpu);
 197     struct kvm_mips_interrupt intr;
 198
 199     if (!kvm_enabled()) {
 200         return 0;
 201     }
 202
 203     intr.cpu = -1;
 204
 205     if (level) {
 206         intr.irq = irq;
 207     } else {
 208         intr.irq = -irq;
 209     }
 210
 211     kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
 212
 213     return 0;
 214 }
 215
 216 int kvm_mips_set_ipi_interrupt(MIPSCPU *cpu, int irq, int level)
 217 {
 218     CPUState *cs = current_cpu;
 219     CPUState *dest_cs = CPU(cpu);
 220     struct kvm_mips_interrupt intr;
 221
 222     if (!kvm_enabled()) {
 223         return 0;
 224     }
 225
 226     intr.cpu = dest_cs->cpu_index;
 227
 228     if (level) {
 229         intr.irq = irq;
 230     } else {
 231         intr.irq = -irq;
 232     }
 233
 234     DPRINTF("%s: CPU %d, IRQ: %d\n", __func__, intr.cpu, intr.irq);
 235
 236     kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
 237
 238     return 0;
 239 }
 240
 241 #define MIPS_CP0_32(_R, _S)                                     \
 242     (KVM_REG_MIPS_CP0 | KVM_REG_SIZE_U32 | (8 * (_R) + (_S)))
 243
 244 #define MIPS_CP0_64(_R, _S)                                     \
 245     (KVM_REG_MIPS_CP0 | KVM_REG_SIZE_U64 | (8 * (_R) + (_S)))
 246
 247 #define KVM_REG_MIPS_CP0_INDEX          MIPS_CP0_32(0, 0)
 248 #define KVM_REG_MIPS_CP0_CONTEXT        MIPS_CP0_64(4, 0)
 249 #define KVM_REG_MIPS_CP0_USERLOCAL      MIPS_CP0_64(4, 2)
 250 #define KVM_REG_MIPS_CP0_PAGEMASK       MIPS_CP0_32(5, 0)
 251 #define KVM_REG_MIPS_CP0_WIRED          MIPS_CP0_32(6, 0)
 252 #define KVM_REG_MIPS_CP0_HWRENA         MIPS_CP0_32(7, 0)
 253 #define KVM_REG_MIPS_CP0_BADVADDR       MIPS_CP0_64(8, 0)
 254 #define KVM_REG_MIPS_CP0_COUNT          MIPS_CP0_32(9, 0)
 255 #define KVM_REG_MIPS_CP0_ENTRYHI        MIPS_CP0_64(10, 0)
 256 #define KVM_REG_MIPS_CP0_COMPARE        MIPS_CP0_32(11, 0)
 257 #define KVM_REG_MIPS_CP0_STATUS         MIPS_CP0_32(12, 0)
 258 #define KVM_REG_MIPS_CP0_CAUSE          MIPS_CP0_32(13, 0)
 259 #define KVM_REG_MIPS_CP0_EPC            MIPS_CP0_64(14, 0)
 260 #define KVM_REG_MIPS_CP0_PRID           MIPS_CP0_32(15, 0)
 261 #define KVM_REG_MIPS_CP0_CONFIG         MIPS_CP0_32(16, 0)
 262 #define KVM_REG_MIPS_CP0_CONFIG1        MIPS_CP0_32(16, 1)
 263 #define KVM_REG_MIPS_CP0_CONFIG2        MIPS_CP0_32(16, 2)
 264 #define KVM_REG_MIPS_CP0_CONFIG3        MIPS_CP0_32(16, 3)
 265 #define KVM_REG_MIPS_CP0_CONFIG4        MIPS_CP0_32(16, 4)
 266 #define KVM_REG_MIPS_CP0_CONFIG5        MIPS_CP0_32(16, 5)
 267 #define KVM_REG_MIPS_CP0_ERROREPC       MIPS_CP0_64(30, 0)
 268
 269 static inline int kvm_mips_put_one_reg(CPUState *cs, uint64_t reg_id,
 270                                        int32_t *addr)
 271 {
 272     struct kvm_one_reg cp0reg = {
 273         .id = reg_id,
 274         .addr = (uintptr_t)addr
 275     };
 276
 277     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
 278 }
 279
 280 static inline int kvm_mips_put_one_ureg(CPUState *cs, uint64_t reg_id,
 281                                         uint32_t *addr)
 282 {
 283     struct kvm_one_reg cp0reg = {
 284         .id = reg_id,
 285         .addr = (uintptr_t)addr
 286     };
 287
 288     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
 289 }
 290
 291 static inline int kvm_mips_put_one_ulreg(CPUState *cs, uint64_t reg_id,
 292                                          target_ulong *addr)
 293 {
 294     uint64_t val64 = *addr;
 295     struct kvm_one_reg cp0reg = {
 296         .id = reg_id,
 297         .addr = (uintptr_t)&val64
 298     };
 299
 300     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
 301 }
 302
 303 static inline int kvm_mips_put_one_reg64(CPUState *cs, uint64_t reg_id,
 304                                          int64_t *addr)
 305 {
 306     struct kvm_one_reg cp0reg = {
 307         .id = reg_id,
 308         .addr = (uintptr_t)addr
 309     };
 310
 311     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
 312 }
 313
 314 static inline int kvm_mips_put_one_ureg64(CPUState *cs, uint64_t reg_id,
 315                                           uint64_t *addr)
 316 {
 317     struct kvm_one_reg cp0reg = {
 318         .id = reg_id,
 319         .addr = (uintptr_t)addr
 320     };
 321
 322     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
 323 }
 324
 325 static inline int kvm_mips_get_one_reg(CPUState *cs, uint64_t reg_id,
 326                                        int32_t *addr)
 327 {
 328     struct kvm_one_reg cp0reg = {
 329         .id = reg_id,
 330         .addr = (uintptr_t)addr
 331     };
 332
 333     return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
 334 }
 335
 336 static inline int kvm_mips_get_one_ureg(CPUState *cs, uint64_t reg_id,
 337                                         uint32_t *addr)
 338 {
 339     struct kvm_one_reg cp0reg = {
 340         .id = reg_id,
 341         .addr = (uintptr_t)addr
 342     };
 343
 344     return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
 345 }
 346
 347 static inline int kvm_mips_get_one_ulreg(CPUState *cs, uint64_t reg_id,
 348                                          target_ulong *addr)
 349 {
 350     int ret;
 351     uint64_t val64 = 0;
 352     struct kvm_one_reg cp0reg = {
 353         .id = reg_id,
 354         .addr = (uintptr_t)&val64
 355     };
 356
 357     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
 358     if (ret >= 0) {
 359         *addr = val64;
 360     }
 361     return ret;
 362 }
 363
 364 static inline int kvm_mips_get_one_reg64(CPUState *cs, uint64_t reg_id,
 365                                          int64_t *addr)
 366 {
 367     struct kvm_one_reg cp0reg = {
 368         .id = reg_id,
 369         .addr = (uintptr_t)addr
 370     };
 371
 372     return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
 373 }
 374
 375 static inline int kvm_mips_get_one_ureg64(CPUState *cs, uint64_t reg_id,
 376                                           uint64_t *addr)
 377 {
 378     struct kvm_one_reg cp0reg = {
 379         .id = reg_id,
 380         .addr = (uintptr_t)addr
 381     };
 382
 383     return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
 384 }
 385
 386 #define KVM_REG_MIPS_CP0_CONFIG_MASK    (1U << CP0C0_M)
 387 #define KVM_REG_MIPS_CP0_CONFIG1_MASK   ((1U << CP0C1_M) | \
 388                                          (1U << CP0C1_FP))
 389 #define KVM_REG_MIPS_CP0_CONFIG2_MASK   (1U << CP0C2_M)
 390 #define KVM_REG_MIPS_CP0_CONFIG3_MASK   ((1U << CP0C3_M) | \
 391                                          (1U << CP0C3_MSAP))
 392 #define KVM_REG_MIPS_CP0_CONFIG4_MASK   (1U << CP0C4_M)
 393 #define KVM_REG_MIPS_CP0_CONFIG5_MASK   ((1U << CP0C5_MSAEn) | \
 394                                          (1U << CP0C5_UFE) | \
 395                                          (1U << CP0C5_FRE) | \
 396                                          (1U << CP0C5_UFR))
 397
 398 static inline int kvm_mips_change_one_reg(CPUState *cs, uint64_t reg_id,
 399                                           int32_t *addr, int32_t mask)
 400 {
 401     int err;
 402     int32_t tmp, change;
 403
 404     err = kvm_mips_get_one_reg(cs, reg_id, &tmp);
 405     if (err < 0) {
 406         return err;
 407     }
 408
 409     /* only change bits in mask */
 410     change = (*addr ^ tmp) & mask;
 411     if (!change) {
 412         return 0;
 413     }
 414
 415     tmp = tmp ^ change;
 416     return kvm_mips_put_one_reg(cs, reg_id, &tmp);
 417 }
 418
 419 /*
 420  * We freeze the KVM timer when either the VM clock is stopped or the state is
 421  * saved (the state is dirty).
 422  */
 423
 424 /*
 425  * Save the state of the KVM timer when VM clock is stopped or state is synced
 426  * to QEMU.
 427  */
 428 static int kvm_mips_save_count(CPUState *cs)
 429 {
 430     MIPSCPU *cpu = MIPS_CPU(cs);
 431     CPUMIPSState *env = &cpu->env;
 432     uint64_t count_ctl;
 433     int err, ret = 0;
 434
 435     /* freeze KVM timer */
 436     err = kvm_mips_get_one_ureg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
 437     if (err < 0) {
 438         DPRINTF("%s: Failed to get COUNT_CTL (%d)\n", __func__, err);
 439         ret = err;
 440     } else if (!(count_ctl & KVM_REG_MIPS_COUNT_CTL_DC)) {
 441         count_ctl |= KVM_REG_MIPS_COUNT_CTL_DC;
 442         err = kvm_mips_put_one_ureg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
 443         if (err < 0) {
 444             DPRINTF("%s: Failed to set COUNT_CTL.DC=1 (%d)\n", __func__, err);
 445             ret = err;
 446         }
 447     }
 448
 449     /* read CP0_Cause */
 450     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CAUSE, &env->CP0_Cause);
 451     if (err < 0) {
 452         DPRINTF("%s: Failed to get CP0_CAUSE (%d)\n", __func__, err);
 453         ret = err;
 454     }
 455
 456     /* read CP0_Count */
 457     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_COUNT, &env->CP0_Count);
 458     if (err < 0) {
 459         DPRINTF("%s: Failed to get CP0_COUNT (%d)\n", __func__, err);
 460         ret = err;
 461     }
 462
 463     return ret;
 464 }
 465
 466 /*
 467  * Restore the state of the KVM timer when VM clock is restarted or state is
 468  * synced to KVM.
 469  */
 470 static int kvm_mips_restore_count(CPUState *cs)
 471 {
 472     MIPSCPU *cpu = MIPS_CPU(cs);
 473     CPUMIPSState *env = &cpu->env;
 474     uint64_t count_ctl;
 475     int err_dc, err, ret = 0;
 476
 477     /* check the timer is frozen */
 478     err_dc = kvm_mips_get_one_ureg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
 479     if (err_dc < 0) {
 480         DPRINTF("%s: Failed to get COUNT_CTL (%d)\n", __func__, err_dc);
 481         ret = err_dc;
 482     } else if (!(count_ctl & KVM_REG_MIPS_COUNT_CTL_DC)) {
 483         /* freeze timer (sets COUNT_RESUME for us) */
 484         count_ctl |= KVM_REG_MIPS_COUNT_CTL_DC;
 485         err = kvm_mips_put_one_ureg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
 486         if (err < 0) {
 487             DPRINTF("%s: Failed to set COUNT_CTL.DC=1 (%d)\n", __func__, err);
 488             ret = err;
 489         }
 490     }
 491
 492     /* load CP0_Cause */
 493     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_CAUSE, &env->CP0_Cause);
 494     if (err < 0) {
 495         DPRINTF("%s: Failed to put CP0_CAUSE (%d)\n", __func__, err);
 496         ret = err;
 497     }
 498
 499     /* load CP0_Count */
 500     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_COUNT, &env->CP0_Count);
 501     if (err < 0) {
 502         DPRINTF("%s: Failed to put CP0_COUNT (%d)\n", __func__, err);
 503         ret = err;
 504     }
 505
 506     /* resume KVM timer */
 507     if (err_dc >= 0) {
 508         count_ctl &= ~KVM_REG_MIPS_COUNT_CTL_DC;
 509         err = kvm_mips_put_one_ureg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
 510         if (err < 0) {
 511             DPRINTF("%s: Failed to set COUNT_CTL.DC=0 (%d)\n", __func__, err);
 512             ret = err;
 513         }
 514     }
 515
 516     return ret;
 517 }
 518
 519 /*
 520  * Handle the VM clock being started or stopped
 521  */
 522 static void kvm_mips_update_state(void *opaque, int running, RunState state)
 523 {
 524     CPUState *cs = opaque;
 525     int ret;
 526     uint64_t count_resume;
 527
 528     /*
 529      * If state is already dirty (synced to QEMU) then the KVM timer state is
 530      * already saved and can be restored when it is synced back to KVM.
 531      */
 532     if (!running) {
 533         if (!cs->kvm_vcpu_dirty) {
 534             ret = kvm_mips_save_count(cs);
 535             if (ret < 0) {
 536                 fprintf(stderr, "Failed saving count\n");
 537             }
 538         }
 539     } else {
 540         /* Set clock restore time to now */
 541         count_resume = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
 542         ret = kvm_mips_put_one_ureg64(cs, KVM_REG_MIPS_COUNT_RESUME,
 543                                       &count_resume);
 544         if (ret < 0) {
 545             fprintf(stderr, "Failed setting COUNT_RESUME\n");
 546             return;
 547         }
 548
 549         if (!cs->kvm_vcpu_dirty) {
 550             ret = kvm_mips_restore_count(cs);
 551             if (ret < 0) {
 552                 fprintf(stderr, "Failed restoring count\n");
 553             }
 554         }
 555     }
 556 }
 557
 558 static int kvm_mips_put_fpu_registers(CPUState *cs, int level)
 559 {
 560     MIPSCPU *cpu = MIPS_CPU(cs);
 561     CPUMIPSState *env = &cpu->env;
 562     int err, ret = 0;
 563     unsigned int i;
 564
 565     /* Only put FPU state if we're emulating a CPU with an FPU */
 566     if (env->CP0_Config1 & (1 << CP0C1_FP)) {
 567         /* FPU Control Registers */
 568         if (level == KVM_PUT_FULL_STATE) {
 569             err = kvm_mips_put_one_ureg(cs, KVM_REG_MIPS_FCR_IR,
 570                                         &env->active_fpu.fcr0);
 571             if (err < 0) {
 572                 DPRINTF("%s: Failed to put FCR_IR (%d)\n", __func__, err);
 573                 ret = err;
 574             }
 575         }
 576         err = kvm_mips_put_one_ureg(cs, KVM_REG_MIPS_FCR_CSR,
 577                                     &env->active_fpu.fcr31);
 578         if (err < 0) {
 579             DPRINTF("%s: Failed to put FCR_CSR (%d)\n", __func__, err);
 580             ret = err;
 581         }
 582
 583         /*
 584          * FPU register state is a subset of MSA vector state, so don't put FPU
 585          * registers if we're emulating a CPU with MSA.
 586          */
 587         if (!(env->CP0_Config3 & (1 << CP0C3_MSAP))) {
 588             /* Floating point registers */
 589             for (i = 0; i < 32; ++i) {
 590                 if (env->CP0_Status & (1 << CP0St_FR)) {
 591                     err = kvm_mips_put_one_ureg64(cs, KVM_REG_MIPS_FPR_64(i),
 592                                                   &env->active_fpu.fpr[i].d);
 593                 } else {
 594                     err = kvm_mips_get_one_ureg(cs, KVM_REG_MIPS_FPR_32(i),
 595                                     &env->active_fpu.fpr[i].w[FP_ENDIAN_IDX]);
 596                 }
 597                 if (err < 0) {
 598                     DPRINTF("%s: Failed to put FPR%u (%d)\n", __func__, i, err);
 599                     ret = err;
 600                 }
 601             }
 602         }
 603     }
 604
 605     /* Only put MSA state if we're emulating a CPU with MSA */
 606     if (env->CP0_Config3 & (1 << CP0C3_MSAP)) {
 607         /* MSA Control Registers */
 608         if (level == KVM_PUT_FULL_STATE) {
 609             err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_MSA_IR,
 610                                        &env->msair);
 611             if (err < 0) {
 612                 DPRINTF("%s: Failed to put MSA_IR (%d)\n", __func__, err);
 613                 ret = err;
 614             }
 615         }
 616         err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_MSA_CSR,
 617                                    &env->active_tc.msacsr);
 618         if (err < 0) {
 619             DPRINTF("%s: Failed to put MSA_CSR (%d)\n", __func__, err);
 620             ret = err;
 621         }
 622
 623         /* Vector registers (includes FP registers) */
 624         for (i = 0; i < 32; ++i) {
 625             /* Big endian MSA not supported by QEMU yet anyway */
 626             err = kvm_mips_put_one_reg64(cs, KVM_REG_MIPS_VEC_128(i),
 627                                          env->active_fpu.fpr[i].wr.d);
 628             if (err < 0) {
 629                 DPRINTF("%s: Failed to put VEC%u (%d)\n", __func__, i, err);
 630                 ret = err;
 631             }
 632         }
 633     }
 634
 635     return ret;
 636 }
 637
 638 static int kvm_mips_get_fpu_registers(CPUState *cs)
 639 {
 640     MIPSCPU *cpu = MIPS_CPU(cs);
 641     CPUMIPSState *env = &cpu->env;
 642     int err, ret = 0;
 643     unsigned int i;
 644
 645     /* Only get FPU state if we're emulating a CPU with an FPU */
 646     if (env->CP0_Config1 & (1 << CP0C1_FP)) {
 647         /* FPU Control Registers */
 648         err = kvm_mips_get_one_ureg(cs, KVM_REG_MIPS_FCR_IR,
 649                                     &env->active_fpu.fcr0);
 650         if (err < 0) {
 651             DPRINTF("%s: Failed to get FCR_IR (%d)\n", __func__, err);
 652             ret = err;
 653         }
 654         err = kvm_mips_get_one_ureg(cs, KVM_REG_MIPS_FCR_CSR,
 655                                     &env->active_fpu.fcr31);
 656         if (err < 0) {
 657             DPRINTF("%s: Failed to get FCR_CSR (%d)\n", __func__, err);
 658             ret = err;
 659         } else {
 660             restore_fp_status(env);
 661         }
 662
 663         /*
 664          * FPU register state is a subset of MSA vector state, so don't save FPU
 665          * registers if we're emulating a CPU with MSA.
 666          */
 667         if (!(env->CP0_Config3 & (1 << CP0C3_MSAP))) {
 668             /* Floating point registers */
 669             for (i = 0; i < 32; ++i) {
 670                 if (env->CP0_Status & (1 << CP0St_FR)) {
 671                     err = kvm_mips_get_one_ureg64(cs, KVM_REG_MIPS_FPR_64(i),
 672                                                   &env->active_fpu.fpr[i].d);
 673                 } else {
 674                     err = kvm_mips_get_one_ureg(cs, KVM_REG_MIPS_FPR_32(i),
 675                                     &env->active_fpu.fpr[i].w[FP_ENDIAN_IDX]);
 676                 }
 677                 if (err < 0) {
 678                     DPRINTF("%s: Failed to get FPR%u (%d)\n", __func__, i, err);
 679                     ret = err;
 680                 }
 681             }
 682         }
 683     }
 684
 685     /* Only get MSA state if we're emulating a CPU with MSA */
 686     if (env->CP0_Config3 & (1 << CP0C3_MSAP)) {
 687         /* MSA Control Registers */
 688         err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_MSA_IR,
 689                                    &env->msair);
 690         if (err < 0) {
 691             DPRINTF("%s: Failed to get MSA_IR (%d)\n", __func__, err);
 692             ret = err;
 693         }
 694         err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_MSA_CSR,
 695                                    &env->active_tc.msacsr);
 696         if (err < 0) {
 697             DPRINTF("%s: Failed to get MSA_CSR (%d)\n", __func__, err);
 698             ret = err;
 699         } else {
 700             restore_msa_fp_status(env);
 701         }
 702
 703         /* Vector registers (includes FP registers) */
 704         for (i = 0; i < 32; ++i) {
 705             /* Big endian MSA not supported by QEMU yet anyway */
 706             err = kvm_mips_get_one_reg64(cs, KVM_REG_MIPS_VEC_128(i),
 707                                          env->active_fpu.fpr[i].wr.d);
 708             if (err < 0) {
 709                 DPRINTF("%s: Failed to get VEC%u (%d)\n", __func__, i, err);
 710                 ret = err;
 711             }
 712         }
 713     }
 714
 715     return ret;
 716 }
 717
 718
 719 static int kvm_mips_put_cp0_registers(CPUState *cs, int level)
 720 {
 721     MIPSCPU *cpu = MIPS_CPU(cs);
 722     CPUMIPSState *env = &cpu->env;
 723     int err, ret = 0;
 724
 725     (void)level;
 726
 727     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_INDEX, &env->CP0_Index);
 728     if (err < 0) {
 729         DPRINTF("%s: Failed to put CP0_INDEX (%d)\n", __func__, err);
 730         ret = err;
 731     }
 732     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_CONTEXT,
 733                                  &env->CP0_Context);
 734     if (err < 0) {
 735         DPRINTF("%s: Failed to put CP0_CONTEXT (%d)\n", __func__, err);
 736         ret = err;
 737     }
 738     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_USERLOCAL,
 739                                  &env->active_tc.CP0_UserLocal);
 740     if (err < 0) {
 741         DPRINTF("%s: Failed to put CP0_USERLOCAL (%d)\n", __func__, err);
 742         ret = err;
 743     }
 744     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_PAGEMASK,
 745                                &env->CP0_PageMask);
 746     if (err < 0) {
 747         DPRINTF("%s: Failed to put CP0_PAGEMASK (%d)\n", __func__, err);
 748         ret = err;
 749     }
 750     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_WIRED, &env->CP0_Wired);
 751     if (err < 0) {
 752         DPRINTF("%s: Failed to put CP0_WIRED (%d)\n", __func__, err);
 753         ret = err;
 754     }
 755     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_HWRENA, &env->CP0_HWREna);
 756     if (err < 0) {
 757         DPRINTF("%s: Failed to put CP0_HWRENA (%d)\n", __func__, err);
 758         ret = err;
 759     }
 760     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_BADVADDR,
 761                                  &env->CP0_BadVAddr);
 762     if (err < 0) {
 763         DPRINTF("%s: Failed to put CP0_BADVADDR (%d)\n", __func__, err);
 764         ret = err;
 765     }
 766
 767     /* If VM clock stopped then state will be restored when it is restarted */
 768     if (runstate_is_running()) {
 769         err = kvm_mips_restore_count(cs);
 770         if (err < 0) {
 771             ret = err;
 772         }
 773     }
 774
 775     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_ENTRYHI,
 776                                  &env->CP0_EntryHi);
 777     if (err < 0) {
 778         DPRINTF("%s: Failed to put CP0_ENTRYHI (%d)\n", __func__, err);
 779         ret = err;
 780     }
 781     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_COMPARE,
 782                                &env->CP0_Compare);
 783     if (err < 0) {
 784         DPRINTF("%s: Failed to put CP0_COMPARE (%d)\n", __func__, err);
 785         ret = err;
 786     }
 787     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_STATUS, &env->CP0_Status);
 788     if (err < 0) {
 789         DPRINTF("%s: Failed to put CP0_STATUS (%d)\n", __func__, err);
 790         ret = err;
 791     }
 792     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_EPC, &env->CP0_EPC);
 793     if (err < 0) {
 794         DPRINTF("%s: Failed to put CP0_EPC (%d)\n", __func__, err);
 795         ret = err;
 796     }
 797     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_PRID, &env->CP0_PRid);
 798     if (err < 0) {
 799         DPRINTF("%s: Failed to put CP0_PRID (%d)\n", __func__, err);
 800         ret = err;
 801     }
 802     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG,
 803                                   &env->CP0_Config0,
 804                                   KVM_REG_MIPS_CP0_CONFIG_MASK);
 805     if (err < 0) {
 806         DPRINTF("%s: Failed to change CP0_CONFIG (%d)\n", __func__, err);
 807         ret = err;
 808     }
 809     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG1,
 810                                   &env->CP0_Config1,
 811                                   KVM_REG_MIPS_CP0_CONFIG1_MASK);
 812     if (err < 0) {
 813         DPRINTF("%s: Failed to change CP0_CONFIG1 (%d)\n", __func__, err);
 814         ret = err;
 815     }
 816     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG2,
 817                                   &env->CP0_Config2,
 818                                   KVM_REG_MIPS_CP0_CONFIG2_MASK);
 819     if (err < 0) {
 820         DPRINTF("%s: Failed to change CP0_CONFIG2 (%d)\n", __func__, err);
 821         ret = err;
 822     }
 823     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG3,
 824                                   &env->CP0_Config3,
 825                                   KVM_REG_MIPS_CP0_CONFIG3_MASK);
 826     if (err < 0) {
 827         DPRINTF("%s: Failed to change CP0_CONFIG3 (%d)\n", __func__, err);
 828         ret = err;
 829     }
 830     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG4,
 831                                   &env->CP0_Config4,
 832                                   KVM_REG_MIPS_CP0_CONFIG4_MASK);
 833     if (err < 0) {
 834         DPRINTF("%s: Failed to change CP0_CONFIG4 (%d)\n", __func__, err);
 835         ret = err;
 836     }
 837     err = kvm_mips_change_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG5,
 838                                   &env->CP0_Config5,
 839                                   KVM_REG_MIPS_CP0_CONFIG5_MASK);
 840     if (err < 0) {
 841         DPRINTF("%s: Failed to change CP0_CONFIG5 (%d)\n", __func__, err);
 842         ret = err;
 843     }
 844     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_ERROREPC,
 845                                  &env->CP0_ErrorEPC);
 846     if (err < 0) {
 847         DPRINTF("%s: Failed to put CP0_ERROREPC (%d)\n", __func__, err);
 848         ret = err;
 849     }
 850
 851     return ret;
 852 }
 853
 854 static int kvm_mips_get_cp0_registers(CPUState *cs)
 855 {
 856     MIPSCPU *cpu = MIPS_CPU(cs);
 857     CPUMIPSState *env = &cpu->env;
 858     int err, ret = 0;
 859
 860     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_INDEX, &env->CP0_Index);
 861     if (err < 0) {
 862         DPRINTF("%s: Failed to get CP0_INDEX (%d)\n", __func__, err);
 863         ret = err;
 864     }
 865     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_CONTEXT,
 866                                  &env->CP0_Context);
 867     if (err < 0) {
 868         DPRINTF("%s: Failed to get CP0_CONTEXT (%d)\n", __func__, err);
 869         ret = err;
 870     }
 871     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_USERLOCAL,
 872                                  &env->active_tc.CP0_UserLocal);
 873     if (err < 0) {
 874         DPRINTF("%s: Failed to get CP0_USERLOCAL (%d)\n", __func__, err);
 875         ret = err;
 876     }
 877     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_PAGEMASK,
 878                                &env->CP0_PageMask);
 879     if (err < 0) {
 880         DPRINTF("%s: Failed to get CP0_PAGEMASK (%d)\n", __func__, err);
 881         ret = err;
 882     }
 883     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_WIRED, &env->CP0_Wired);
 884     if (err < 0) {
 885         DPRINTF("%s: Failed to get CP0_WIRED (%d)\n", __func__, err);
 886         ret = err;
 887     }
 888     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_HWRENA, &env->CP0_HWREna);
 889     if (err < 0) {
 890         DPRINTF("%s: Failed to get CP0_HWRENA (%d)\n", __func__, err);
 891         ret = err;
 892     }
 893     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_BADVADDR,
 894                                  &env->CP0_BadVAddr);
 895     if (err < 0) {
 896         DPRINTF("%s: Failed to get CP0_BADVADDR (%d)\n", __func__, err);
 897         ret = err;
 898     }
 899     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_ENTRYHI,
 900                                  &env->CP0_EntryHi);
 901     if (err < 0) {
 902         DPRINTF("%s: Failed to get CP0_ENTRYHI (%d)\n", __func__, err);
 903         ret = err;
 904     }
 905     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_COMPARE,
 906                                &env->CP0_Compare);
 907     if (err < 0) {
 908         DPRINTF("%s: Failed to get CP0_COMPARE (%d)\n", __func__, err);
 909         ret = err;
 910     }
 911     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_STATUS, &env->CP0_Status);
 912     if (err < 0) {
 913         DPRINTF("%s: Failed to get CP0_STATUS (%d)\n", __func__, err);
 914         ret = err;
 915     }
 916
 917     /* If VM clock stopped then state was already saved when it was stopped */
 918     if (runstate_is_running()) {
 919         err = kvm_mips_save_count(cs);
 920         if (err < 0) {
 921             ret = err;
 922         }
 923     }
 924
 925     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_EPC, &env->CP0_EPC);
 926     if (err < 0) {
 927         DPRINTF("%s: Failed to get CP0_EPC (%d)\n", __func__, err);
 928         ret = err;
 929     }
 930     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_PRID, &env->CP0_PRid);
 931     if (err < 0) {
 932         DPRINTF("%s: Failed to get CP0_PRID (%d)\n", __func__, err);
 933         ret = err;
 934     }
 935     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG, &env->CP0_Config0);
 936     if (err < 0) {
 937         DPRINTF("%s: Failed to get CP0_CONFIG (%d)\n", __func__, err);
 938         ret = err;
 939     }
 940     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG1, &env->CP0_Config1);
 941     if (err < 0) {
 942         DPRINTF("%s: Failed to get CP0_CONFIG1 (%d)\n", __func__, err);
 943         ret = err;
 944     }
 945     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG2, &env->CP0_Config2);
 946     if (err < 0) {
 947         DPRINTF("%s: Failed to get CP0_CONFIG2 (%d)\n", __func__, err);
 948         ret = err;
 949     }
 950     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG3, &env->CP0_Config3);
 951     if (err < 0) {
 952         DPRINTF("%s: Failed to get CP0_CONFIG3 (%d)\n", __func__, err);
 953         ret = err;
 954     }
 955     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG4, &env->CP0_Config4);
 956     if (err < 0) {
 957         DPRINTF("%s: Failed to get CP0_CONFIG4 (%d)\n", __func__, err);
 958         ret = err;
 959     }
 960     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CONFIG5, &env->CP0_Config5);
 961     if (err < 0) {
 962         DPRINTF("%s: Failed to get CP0_CONFIG5 (%d)\n", __func__, err);
 963         ret = err;
 964     }
 965     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_ERROREPC,
 966                                  &env->CP0_ErrorEPC);
 967     if (err < 0) {
 968         DPRINTF("%s: Failed to get CP0_ERROREPC (%d)\n", __func__, err);
 969         ret = err;
 970     }
 971
 972     return ret;
 973 }
 974
 975 int kvm_arch_put_registers(CPUState *cs, int level)
 976 {
 977     MIPSCPU *cpu = MIPS_CPU(cs);
 978     CPUMIPSState *env = &cpu->env;
 979     struct kvm_regs regs;
 980     int ret;
 981     int i;
 982
 983     /* Set the registers based on QEMU's view of things */
 984     for (i = 0; i < 32; i++) {
 985         regs.gpr[i] = (int64_t)(target_long)env->active_tc.gpr[i];
 986     }
 987
 988     regs.hi = (int64_t)(target_long)env->active_tc.HI[0];
 989     regs.lo = (int64_t)(target_long)env->active_tc.LO[0];
 990     regs.pc = (int64_t)(target_long)env->active_tc.PC;
 991
 992     ret = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
 993
 994     if (ret < 0) {
 995         return ret;
 996     }
 997
 998     ret = kvm_mips_put_cp0_registers(cs, level);
 999     if (ret < 0) {
1000         return ret;
1001     }
1002
1003     ret = kvm_mips_put_fpu_registers(cs, level);
1004     if (ret < 0) {
1005         return ret;
1006     }
1007
1008     return ret;
1009 }
1010
1011 int kvm_arch_get_registers(CPUState *cs)
1012 {
1013     MIPSCPU *cpu = MIPS_CPU(cs);
1014     CPUMIPSState *env = &cpu->env;
1015     int ret = 0;
1016     struct kvm_regs regs;
1017     int i;
1018
1019     /* Get the current register set as KVM seems it */
1020     ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
1021
1022     if (ret < 0) {
1023         return ret;
1024     }
1025
1026     for (i = 0; i < 32; i++) {
1027         env->active_tc.gpr[i] = regs.gpr[i];
1028     }
1029
1030     env->active_tc.HI[0] = regs.hi;
1031     env->active_tc.LO[0] = regs.lo;
1032     env->active_tc.PC = regs.pc;
1033
1034     kvm_mips_get_cp0_registers(cs);
1035     kvm_mips_get_fpu_registers(cs);
1036
1037     return ret;
1038 }
1039
1040 int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
1041                              uint64_t address, uint32_t data, PCIDevice *dev)
1042 {
1043     return 0;
1044 }
1045
1046 int kvm_arch_add_msi_route_post(struct kvm_irq_routing_entry *route,
1047                                 int vector, PCIDevice *dev)
1048 {
1049     return 0;
1050 }
1051
1052 int kvm_arch_release_virq_post(int virq)
1053 {
1054     return 0;
1055 }
1056
1057 int kvm_arch_msi_data_to_gsi(uint32_t data)
1058 {
1059     abort();
1060 }