Added license information
[kvmfornfv.git] / qemu / 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 <sys/types.h>
13 #include <sys/ioctl.h>
14 #include <sys/mman.h>
15
16 #include <linux/kvm.h>
17
18 #include "qemu-common.h"
19 #include "qemu/error-report.h"
20 #include "qemu/timer.h"
21 #include "sysemu/sysemu.h"
22 #include "sysemu/kvm.h"
23 #include "cpu.h"
24 #include "sysemu/cpus.h"
25 #include "kvm_mips.h"
26 #include "exec/memattrs.h"
27
28 #define DEBUG_KVM 0
29
30 #define DPRINTF(fmt, ...) \
31     do { if (DEBUG_KVM) { fprintf(stderr, fmt, ## __VA_ARGS__); } } while (0)
32
33 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
34     KVM_CAP_LAST_INFO
35 };
36
37 static void kvm_mips_update_state(void *opaque, int running, RunState state);
38
39 unsigned long kvm_arch_vcpu_id(CPUState *cs)
40 {
41     return cs->cpu_index;
42 }
43
44 int kvm_arch_init(MachineState *ms, KVMState *s)
45 {
46     /* MIPS has 128 signals */
47     kvm_set_sigmask_len(s, 16);
48
49     DPRINTF("%s\n", __func__);
50     return 0;
51 }
52
53 int kvm_arch_init_vcpu(CPUState *cs)
54 {
55     int ret = 0;
56
57     qemu_add_vm_change_state_handler(kvm_mips_update_state, cs);
58
59     DPRINTF("%s\n", __func__);
60     return ret;
61 }
62
63 void kvm_mips_reset_vcpu(MIPSCPU *cpu)
64 {
65     CPUMIPSState *env = &cpu->env;
66
67     if (env->CP0_Config1 & (1 << CP0C1_FP)) {
68         fprintf(stderr, "Warning: FPU not supported with KVM, disabling\n");
69         env->CP0_Config1 &= ~(1 << CP0C1_FP);
70     }
71
72     DPRINTF("%s\n", __func__);
73 }
74
75 int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
76 {
77     DPRINTF("%s\n", __func__);
78     return 0;
79 }
80
81 int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
82 {
83     DPRINTF("%s\n", __func__);
84     return 0;
85 }
86
87 static inline int cpu_mips_io_interrupts_pending(MIPSCPU *cpu)
88 {
89     CPUMIPSState *env = &cpu->env;
90
91     DPRINTF("%s: %#x\n", __func__, env->CP0_Cause & (1 << (2 + CP0Ca_IP)));
92     return env->CP0_Cause & (0x1 << (2 + CP0Ca_IP));
93 }
94
95
96 void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
97 {
98     MIPSCPU *cpu = MIPS_CPU(cs);
99     int r;
100     struct kvm_mips_interrupt intr;
101
102     qemu_mutex_lock_iothread();
103
104     if ((cs->interrupt_request & CPU_INTERRUPT_HARD) &&
105             cpu_mips_io_interrupts_pending(cpu)) {
106         intr.cpu = -1;
107         intr.irq = 2;
108         r = kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
109         if (r < 0) {
110             error_report("%s: cpu %d: failed to inject IRQ %x",
111                          __func__, cs->cpu_index, intr.irq);
112         }
113     }
114
115     qemu_mutex_unlock_iothread();
116 }
117
118 MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)
119 {
120     DPRINTF("%s\n", __func__);
121     return MEMTXATTRS_UNSPECIFIED;
122 }
123
124 int kvm_arch_process_async_events(CPUState *cs)
125 {
126     return cs->halted;
127 }
128
129 int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
130 {
131     int ret;
132
133     DPRINTF("%s\n", __func__);
134     switch (run->exit_reason) {
135     default:
136         error_report("%s: unknown exit reason %d",
137                      __func__, run->exit_reason);
138         ret = -1;
139         break;
140     }
141
142     return ret;
143 }
144
145 bool kvm_arch_stop_on_emulation_error(CPUState *cs)
146 {
147     DPRINTF("%s\n", __func__);
148     return true;
149 }
150
151 int kvm_arch_on_sigbus_vcpu(CPUState *cs, int code, void *addr)
152 {
153     DPRINTF("%s\n", __func__);
154     return 1;
155 }
156
157 int kvm_arch_on_sigbus(int code, void *addr)
158 {
159     DPRINTF("%s\n", __func__);
160     return 1;
161 }
162
163 void kvm_arch_init_irq_routing(KVMState *s)
164 {
165 }
166
167 int kvm_mips_set_interrupt(MIPSCPU *cpu, int irq, int level)
168 {
169     CPUState *cs = CPU(cpu);
170     struct kvm_mips_interrupt intr;
171
172     if (!kvm_enabled()) {
173         return 0;
174     }
175
176     intr.cpu = -1;
177
178     if (level) {
179         intr.irq = irq;
180     } else {
181         intr.irq = -irq;
182     }
183
184     kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
185
186     return 0;
187 }
188
189 int kvm_mips_set_ipi_interrupt(MIPSCPU *cpu, int irq, int level)
190 {
191     CPUState *cs = current_cpu;
192     CPUState *dest_cs = CPU(cpu);
193     struct kvm_mips_interrupt intr;
194
195     if (!kvm_enabled()) {
196         return 0;
197     }
198
199     intr.cpu = dest_cs->cpu_index;
200
201     if (level) {
202         intr.irq = irq;
203     } else {
204         intr.irq = -irq;
205     }
206
207     DPRINTF("%s: CPU %d, IRQ: %d\n", __func__, intr.cpu, intr.irq);
208
209     kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &intr);
210
211     return 0;
212 }
213
214 #define MIPS_CP0_32(_R, _S)                                     \
215     (KVM_REG_MIPS_CP0 | KVM_REG_SIZE_U32 | (8 * (_R) + (_S)))
216
217 #define MIPS_CP0_64(_R, _S)                                     \
218     (KVM_REG_MIPS_CP0 | KVM_REG_SIZE_U64 | (8 * (_R) + (_S)))
219
220 #define KVM_REG_MIPS_CP0_INDEX          MIPS_CP0_32(0, 0)
221 #define KVM_REG_MIPS_CP0_CONTEXT        MIPS_CP0_64(4, 0)
222 #define KVM_REG_MIPS_CP0_USERLOCAL      MIPS_CP0_64(4, 2)
223 #define KVM_REG_MIPS_CP0_PAGEMASK       MIPS_CP0_32(5, 0)
224 #define KVM_REG_MIPS_CP0_WIRED          MIPS_CP0_32(6, 0)
225 #define KVM_REG_MIPS_CP0_HWRENA         MIPS_CP0_32(7, 0)
226 #define KVM_REG_MIPS_CP0_BADVADDR       MIPS_CP0_64(8, 0)
227 #define KVM_REG_MIPS_CP0_COUNT          MIPS_CP0_32(9, 0)
228 #define KVM_REG_MIPS_CP0_ENTRYHI        MIPS_CP0_64(10, 0)
229 #define KVM_REG_MIPS_CP0_COMPARE        MIPS_CP0_32(11, 0)
230 #define KVM_REG_MIPS_CP0_STATUS         MIPS_CP0_32(12, 0)
231 #define KVM_REG_MIPS_CP0_CAUSE          MIPS_CP0_32(13, 0)
232 #define KVM_REG_MIPS_CP0_EPC            MIPS_CP0_64(14, 0)
233 #define KVM_REG_MIPS_CP0_ERROREPC       MIPS_CP0_64(30, 0)
234
235 static inline int kvm_mips_put_one_reg(CPUState *cs, uint64_t reg_id,
236                                        int32_t *addr)
237 {
238     struct kvm_one_reg cp0reg = {
239         .id = reg_id,
240         .addr = (uintptr_t)addr
241     };
242
243     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
244 }
245
246 static inline int kvm_mips_put_one_ulreg(CPUState *cs, uint64_t reg_id,
247                                          target_ulong *addr)
248 {
249     uint64_t val64 = *addr;
250     struct kvm_one_reg cp0reg = {
251         .id = reg_id,
252         .addr = (uintptr_t)&val64
253     };
254
255     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
256 }
257
258 static inline int kvm_mips_put_one_reg64(CPUState *cs, uint64_t reg_id,
259                                          uint64_t *addr)
260 {
261     struct kvm_one_reg cp0reg = {
262         .id = reg_id,
263         .addr = (uintptr_t)addr
264     };
265
266     return kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &cp0reg);
267 }
268
269 static inline int kvm_mips_get_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_GET_ONE_REG, &cp0reg);
278 }
279
280 static inline int kvm_mips_get_one_ulreg(CPUState *cs, uint64 reg_id,
281                                          target_ulong *addr)
282 {
283     int ret;
284     uint64_t val64 = 0;
285     struct kvm_one_reg cp0reg = {
286         .id = reg_id,
287         .addr = (uintptr_t)&val64
288     };
289
290     ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
291     if (ret >= 0) {
292         *addr = val64;
293     }
294     return ret;
295 }
296
297 static inline int kvm_mips_get_one_reg64(CPUState *cs, uint64 reg_id,
298                                          uint64_t *addr)
299 {
300     struct kvm_one_reg cp0reg = {
301         .id = reg_id,
302         .addr = (uintptr_t)addr
303     };
304
305     return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
306 }
307
308 /*
309  * We freeze the KVM timer when either the VM clock is stopped or the state is
310  * saved (the state is dirty).
311  */
312
313 /*
314  * Save the state of the KVM timer when VM clock is stopped or state is synced
315  * to QEMU.
316  */
317 static int kvm_mips_save_count(CPUState *cs)
318 {
319     MIPSCPU *cpu = MIPS_CPU(cs);
320     CPUMIPSState *env = &cpu->env;
321     uint64_t count_ctl;
322     int err, ret = 0;
323
324     /* freeze KVM timer */
325     err = kvm_mips_get_one_reg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
326     if (err < 0) {
327         DPRINTF("%s: Failed to get COUNT_CTL (%d)\n", __func__, err);
328         ret = err;
329     } else if (!(count_ctl & KVM_REG_MIPS_COUNT_CTL_DC)) {
330         count_ctl |= KVM_REG_MIPS_COUNT_CTL_DC;
331         err = kvm_mips_put_one_reg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
332         if (err < 0) {
333             DPRINTF("%s: Failed to set COUNT_CTL.DC=1 (%d)\n", __func__, err);
334             ret = err;
335         }
336     }
337
338     /* read CP0_Cause */
339     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_CAUSE, &env->CP0_Cause);
340     if (err < 0) {
341         DPRINTF("%s: Failed to get CP0_CAUSE (%d)\n", __func__, err);
342         ret = err;
343     }
344
345     /* read CP0_Count */
346     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_COUNT, &env->CP0_Count);
347     if (err < 0) {
348         DPRINTF("%s: Failed to get CP0_COUNT (%d)\n", __func__, err);
349         ret = err;
350     }
351
352     return ret;
353 }
354
355 /*
356  * Restore the state of the KVM timer when VM clock is restarted or state is
357  * synced to KVM.
358  */
359 static int kvm_mips_restore_count(CPUState *cs)
360 {
361     MIPSCPU *cpu = MIPS_CPU(cs);
362     CPUMIPSState *env = &cpu->env;
363     uint64_t count_ctl;
364     int err_dc, err, ret = 0;
365
366     /* check the timer is frozen */
367     err_dc = kvm_mips_get_one_reg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
368     if (err_dc < 0) {
369         DPRINTF("%s: Failed to get COUNT_CTL (%d)\n", __func__, err_dc);
370         ret = err_dc;
371     } else if (!(count_ctl & KVM_REG_MIPS_COUNT_CTL_DC)) {
372         /* freeze timer (sets COUNT_RESUME for us) */
373         count_ctl |= KVM_REG_MIPS_COUNT_CTL_DC;
374         err = kvm_mips_put_one_reg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
375         if (err < 0) {
376             DPRINTF("%s: Failed to set COUNT_CTL.DC=1 (%d)\n", __func__, err);
377             ret = err;
378         }
379     }
380
381     /* load CP0_Cause */
382     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_CAUSE, &env->CP0_Cause);
383     if (err < 0) {
384         DPRINTF("%s: Failed to put CP0_CAUSE (%d)\n", __func__, err);
385         ret = err;
386     }
387
388     /* load CP0_Count */
389     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_COUNT, &env->CP0_Count);
390     if (err < 0) {
391         DPRINTF("%s: Failed to put CP0_COUNT (%d)\n", __func__, err);
392         ret = err;
393     }
394
395     /* resume KVM timer */
396     if (err_dc >= 0) {
397         count_ctl &= ~KVM_REG_MIPS_COUNT_CTL_DC;
398         err = kvm_mips_put_one_reg64(cs, KVM_REG_MIPS_COUNT_CTL, &count_ctl);
399         if (err < 0) {
400             DPRINTF("%s: Failed to set COUNT_CTL.DC=0 (%d)\n", __func__, err);
401             ret = err;
402         }
403     }
404
405     return ret;
406 }
407
408 /*
409  * Handle the VM clock being started or stopped
410  */
411 static void kvm_mips_update_state(void *opaque, int running, RunState state)
412 {
413     CPUState *cs = opaque;
414     int ret;
415     uint64_t count_resume;
416
417     /*
418      * If state is already dirty (synced to QEMU) then the KVM timer state is
419      * already saved and can be restored when it is synced back to KVM.
420      */
421     if (!running) {
422         if (!cs->kvm_vcpu_dirty) {
423             ret = kvm_mips_save_count(cs);
424             if (ret < 0) {
425                 fprintf(stderr, "Failed saving count\n");
426             }
427         }
428     } else {
429         /* Set clock restore time to now */
430         count_resume = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
431         ret = kvm_mips_put_one_reg64(cs, KVM_REG_MIPS_COUNT_RESUME,
432                                      &count_resume);
433         if (ret < 0) {
434             fprintf(stderr, "Failed setting COUNT_RESUME\n");
435             return;
436         }
437
438         if (!cs->kvm_vcpu_dirty) {
439             ret = kvm_mips_restore_count(cs);
440             if (ret < 0) {
441                 fprintf(stderr, "Failed restoring count\n");
442             }
443         }
444     }
445 }
446
447 static int kvm_mips_put_cp0_registers(CPUState *cs, int level)
448 {
449     MIPSCPU *cpu = MIPS_CPU(cs);
450     CPUMIPSState *env = &cpu->env;
451     int err, ret = 0;
452
453     (void)level;
454
455     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_INDEX, &env->CP0_Index);
456     if (err < 0) {
457         DPRINTF("%s: Failed to put CP0_INDEX (%d)\n", __func__, err);
458         ret = err;
459     }
460     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_CONTEXT,
461                                  &env->CP0_Context);
462     if (err < 0) {
463         DPRINTF("%s: Failed to put CP0_CONTEXT (%d)\n", __func__, err);
464         ret = err;
465     }
466     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_USERLOCAL,
467                                  &env->active_tc.CP0_UserLocal);
468     if (err < 0) {
469         DPRINTF("%s: Failed to put CP0_USERLOCAL (%d)\n", __func__, err);
470         ret = err;
471     }
472     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_PAGEMASK,
473                                &env->CP0_PageMask);
474     if (err < 0) {
475         DPRINTF("%s: Failed to put CP0_PAGEMASK (%d)\n", __func__, err);
476         ret = err;
477     }
478     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_WIRED, &env->CP0_Wired);
479     if (err < 0) {
480         DPRINTF("%s: Failed to put CP0_WIRED (%d)\n", __func__, err);
481         ret = err;
482     }
483     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_HWRENA, &env->CP0_HWREna);
484     if (err < 0) {
485         DPRINTF("%s: Failed to put CP0_HWRENA (%d)\n", __func__, err);
486         ret = err;
487     }
488     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_BADVADDR,
489                                  &env->CP0_BadVAddr);
490     if (err < 0) {
491         DPRINTF("%s: Failed to put CP0_BADVADDR (%d)\n", __func__, err);
492         ret = err;
493     }
494
495     /* If VM clock stopped then state will be restored when it is restarted */
496     if (runstate_is_running()) {
497         err = kvm_mips_restore_count(cs);
498         if (err < 0) {
499             ret = err;
500         }
501     }
502
503     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_ENTRYHI,
504                                  &env->CP0_EntryHi);
505     if (err < 0) {
506         DPRINTF("%s: Failed to put CP0_ENTRYHI (%d)\n", __func__, err);
507         ret = err;
508     }
509     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_COMPARE,
510                                &env->CP0_Compare);
511     if (err < 0) {
512         DPRINTF("%s: Failed to put CP0_COMPARE (%d)\n", __func__, err);
513         ret = err;
514     }
515     err = kvm_mips_put_one_reg(cs, KVM_REG_MIPS_CP0_STATUS, &env->CP0_Status);
516     if (err < 0) {
517         DPRINTF("%s: Failed to put CP0_STATUS (%d)\n", __func__, err);
518         ret = err;
519     }
520     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_EPC, &env->CP0_EPC);
521     if (err < 0) {
522         DPRINTF("%s: Failed to put CP0_EPC (%d)\n", __func__, err);
523         ret = err;
524     }
525     err = kvm_mips_put_one_ulreg(cs, KVM_REG_MIPS_CP0_ERROREPC,
526                                  &env->CP0_ErrorEPC);
527     if (err < 0) {
528         DPRINTF("%s: Failed to put CP0_ERROREPC (%d)\n", __func__, err);
529         ret = err;
530     }
531
532     return ret;
533 }
534
535 static int kvm_mips_get_cp0_registers(CPUState *cs)
536 {
537     MIPSCPU *cpu = MIPS_CPU(cs);
538     CPUMIPSState *env = &cpu->env;
539     int err, ret = 0;
540
541     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_INDEX, &env->CP0_Index);
542     if (err < 0) {
543         DPRINTF("%s: Failed to get CP0_INDEX (%d)\n", __func__, err);
544         ret = err;
545     }
546     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_CONTEXT,
547                                  &env->CP0_Context);
548     if (err < 0) {
549         DPRINTF("%s: Failed to get CP0_CONTEXT (%d)\n", __func__, err);
550         ret = err;
551     }
552     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_USERLOCAL,
553                                  &env->active_tc.CP0_UserLocal);
554     if (err < 0) {
555         DPRINTF("%s: Failed to get CP0_USERLOCAL (%d)\n", __func__, err);
556         ret = err;
557     }
558     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_PAGEMASK,
559                                &env->CP0_PageMask);
560     if (err < 0) {
561         DPRINTF("%s: Failed to get CP0_PAGEMASK (%d)\n", __func__, err);
562         ret = err;
563     }
564     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_WIRED, &env->CP0_Wired);
565     if (err < 0) {
566         DPRINTF("%s: Failed to get CP0_WIRED (%d)\n", __func__, err);
567         ret = err;
568     }
569     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_HWRENA, &env->CP0_HWREna);
570     if (err < 0) {
571         DPRINTF("%s: Failed to get CP0_HWRENA (%d)\n", __func__, err);
572         ret = err;
573     }
574     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_BADVADDR,
575                                  &env->CP0_BadVAddr);
576     if (err < 0) {
577         DPRINTF("%s: Failed to get CP0_BADVADDR (%d)\n", __func__, err);
578         ret = err;
579     }
580     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_ENTRYHI,
581                                  &env->CP0_EntryHi);
582     if (err < 0) {
583         DPRINTF("%s: Failed to get CP0_ENTRYHI (%d)\n", __func__, err);
584         ret = err;
585     }
586     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_COMPARE,
587                                &env->CP0_Compare);
588     if (err < 0) {
589         DPRINTF("%s: Failed to get CP0_COMPARE (%d)\n", __func__, err);
590         ret = err;
591     }
592     err = kvm_mips_get_one_reg(cs, KVM_REG_MIPS_CP0_STATUS, &env->CP0_Status);
593     if (err < 0) {
594         DPRINTF("%s: Failed to get CP0_STATUS (%d)\n", __func__, err);
595         ret = err;
596     }
597
598     /* If VM clock stopped then state was already saved when it was stopped */
599     if (runstate_is_running()) {
600         err = kvm_mips_save_count(cs);
601         if (err < 0) {
602             ret = err;
603         }
604     }
605
606     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_EPC, &env->CP0_EPC);
607     if (err < 0) {
608         DPRINTF("%s: Failed to get CP0_EPC (%d)\n", __func__, err);
609         ret = err;
610     }
611     err = kvm_mips_get_one_ulreg(cs, KVM_REG_MIPS_CP0_ERROREPC,
612                                  &env->CP0_ErrorEPC);
613     if (err < 0) {
614         DPRINTF("%s: Failed to get CP0_ERROREPC (%d)\n", __func__, err);
615         ret = err;
616     }
617
618     return ret;
619 }
620
621 int kvm_arch_put_registers(CPUState *cs, int level)
622 {
623     MIPSCPU *cpu = MIPS_CPU(cs);
624     CPUMIPSState *env = &cpu->env;
625     struct kvm_regs regs;
626     int ret;
627     int i;
628
629     /* Set the registers based on QEMU's view of things */
630     for (i = 0; i < 32; i++) {
631         regs.gpr[i] = (int64_t)(target_long)env->active_tc.gpr[i];
632     }
633
634     regs.hi = (int64_t)(target_long)env->active_tc.HI[0];
635     regs.lo = (int64_t)(target_long)env->active_tc.LO[0];
636     regs.pc = (int64_t)(target_long)env->active_tc.PC;
637
638     ret = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
639
640     if (ret < 0) {
641         return ret;
642     }
643
644     ret = kvm_mips_put_cp0_registers(cs, level);
645     if (ret < 0) {
646         return ret;
647     }
648
649     return ret;
650 }
651
652 int kvm_arch_get_registers(CPUState *cs)
653 {
654     MIPSCPU *cpu = MIPS_CPU(cs);
655     CPUMIPSState *env = &cpu->env;
656     int ret = 0;
657     struct kvm_regs regs;
658     int i;
659
660     /* Get the current register set as KVM seems it */
661     ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
662
663     if (ret < 0) {
664         return ret;
665     }
666
667     for (i = 0; i < 32; i++) {
668         env->active_tc.gpr[i] = regs.gpr[i];
669     }
670
671     env->active_tc.HI[0] = regs.hi;
672     env->active_tc.LO[0] = regs.lo;
673     env->active_tc.PC = regs.pc;
674
675     kvm_mips_get_cp0_registers(cs);
676
677     return ret;
678 }
679
680 int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
681                              uint64_t address, uint32_t data)
682 {
683     return 0;
684 }
685
686 int kvm_arch_msi_data_to_gsi(uint32_t data)
687 {
688     abort();
689 }