← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to target-mips/kvm.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
}