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
6 * KVM/MIPS: Instruction/Exception emulation
8 * Copyright (C) 2012 MIPS Technologies, Inc. All rights reserved.
9 * Authors: Sanjay Lal <sanjayl@kymasys.com>
12 #include <linux/errno.h>
13 #include <linux/err.h>
14 #include <linux/kvm_host.h>
15 #include <linux/module.h>
16 #include <linux/vmalloc.h>
18 #include <linux/bootmem.h>
19 #include <linux/random.h>
21 #include <asm/cacheflush.h>
22 #include <asm/cpu-info.h>
23 #include <asm/mmu_context.h>
24 #include <asm/tlbflush.h>
28 #include <asm/r4kcache.h>
29 #define CONFIG_MIPS_MT
31 #include "kvm_mips_opcode.h"
32 #include "kvm_mips_int.h"
33 #include "kvm_mips_comm.h"
38 * Compute the return address and do emulate branch simulation, if required.
39 * This function should be called only in branch delay slot active.
41 unsigned long kvm_compute_return_epc(struct kvm_vcpu
*vcpu
,
44 unsigned int dspcontrol
;
45 union mips_instruction insn
;
46 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
48 long nextpc
= KVM_INVALID_INST
;
54 * Read the instruction
56 insn
.word
= kvm_get_inst((uint32_t *) epc
, vcpu
);
58 if (insn
.word
== KVM_INVALID_INST
)
59 return KVM_INVALID_INST
;
61 switch (insn
.i_format
.opcode
) {
63 * jr and jalr are in r_format format.
66 switch (insn
.r_format
.func
) {
68 arch
->gprs
[insn
.r_format
.rd
] = epc
+ 8;
71 nextpc
= arch
->gprs
[insn
.r_format
.rs
];
77 * This group contains:
78 * bltz_op, bgez_op, bltzl_op, bgezl_op,
79 * bltzal_op, bgezal_op, bltzall_op, bgezall_op.
82 switch (insn
.i_format
.rt
) {
85 if ((long)arch
->gprs
[insn
.i_format
.rs
] < 0)
86 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
94 if ((long)arch
->gprs
[insn
.i_format
.rs
] >= 0)
95 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
103 arch
->gprs
[31] = epc
+ 8;
104 if ((long)arch
->gprs
[insn
.i_format
.rs
] < 0)
105 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
113 arch
->gprs
[31] = epc
+ 8;
114 if ((long)arch
->gprs
[insn
.i_format
.rs
] >= 0)
115 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
124 dspcontrol
= rddsp(0x01);
126 if (dspcontrol
>= 32) {
127 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
136 * These are unconditional and in j_format.
139 arch
->gprs
[31] = instpc
+ 8;
144 epc
|= (insn
.j_format
.target
<< 2);
149 * These are conditional and in i_format.
153 if (arch
->gprs
[insn
.i_format
.rs
] ==
154 arch
->gprs
[insn
.i_format
.rt
])
155 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
163 if (arch
->gprs
[insn
.i_format
.rs
] !=
164 arch
->gprs
[insn
.i_format
.rt
])
165 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
171 case blez_op
: /* not really i_format */
173 /* rt field assumed to be zero */
174 if ((long)arch
->gprs
[insn
.i_format
.rs
] <= 0)
175 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
183 /* rt field assumed to be zero */
184 if ((long)arch
->gprs
[insn
.i_format
.rs
] > 0)
185 epc
= epc
+ 4 + (insn
.i_format
.simmediate
<< 2);
192 * And now the FPA/cp1 branch instructions.
195 printk("%s: unsupported cop1_op\n", __func__
);
202 printk("%s: unaligned epc\n", __func__
);
206 printk("%s: DSP branch but not DSP ASE\n", __func__
);
210 enum emulation_result
update_pc(struct kvm_vcpu
*vcpu
, uint32_t cause
)
212 unsigned long branch_pc
;
213 enum emulation_result er
= EMULATE_DONE
;
215 if (cause
& CAUSEF_BD
) {
216 branch_pc
= kvm_compute_return_epc(vcpu
, vcpu
->arch
.pc
);
217 if (branch_pc
== KVM_INVALID_INST
) {
220 vcpu
->arch
.pc
= branch_pc
;
221 kvm_debug("BD update_pc(): New PC: %#lx\n", vcpu
->arch
.pc
);
226 kvm_debug("update_pc(): New PC: %#lx\n", vcpu
->arch
.pc
);
231 /* Everytime the compare register is written to, we need to decide when to fire
232 * the timer that represents timer ticks to the GUEST.
235 enum emulation_result
kvm_mips_emulate_count(struct kvm_vcpu
*vcpu
)
237 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
238 enum emulation_result er
= EMULATE_DONE
;
240 /* If COUNT is enabled */
241 if (!(kvm_read_c0_guest_cause(cop0
) & CAUSEF_DC
)) {
242 hrtimer_try_to_cancel(&vcpu
->arch
.comparecount_timer
);
243 hrtimer_start(&vcpu
->arch
.comparecount_timer
,
244 ktime_set(0, MS_TO_NS(10)), HRTIMER_MODE_REL
);
246 hrtimer_try_to_cancel(&vcpu
->arch
.comparecount_timer
);
252 enum emulation_result
kvm_mips_emul_eret(struct kvm_vcpu
*vcpu
)
254 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
255 enum emulation_result er
= EMULATE_DONE
;
257 if (kvm_read_c0_guest_status(cop0
) & ST0_EXL
) {
258 kvm_debug("[%#lx] ERET to %#lx\n", vcpu
->arch
.pc
,
259 kvm_read_c0_guest_epc(cop0
));
260 kvm_clear_c0_guest_status(cop0
, ST0_EXL
);
261 vcpu
->arch
.pc
= kvm_read_c0_guest_epc(cop0
);
263 } else if (kvm_read_c0_guest_status(cop0
) & ST0_ERL
) {
264 kvm_clear_c0_guest_status(cop0
, ST0_ERL
);
265 vcpu
->arch
.pc
= kvm_read_c0_guest_errorepc(cop0
);
267 printk("[%#lx] ERET when MIPS_SR_EXL|MIPS_SR_ERL == 0\n",
275 enum emulation_result
kvm_mips_emul_wait(struct kvm_vcpu
*vcpu
)
277 enum emulation_result er
= EMULATE_DONE
;
279 kvm_debug("[%#lx] !!!WAIT!!! (%#lx)\n", vcpu
->arch
.pc
,
280 vcpu
->arch
.pending_exceptions
);
282 ++vcpu
->stat
.wait_exits
;
283 trace_kvm_exit(vcpu
, WAIT_EXITS
);
284 if (!vcpu
->arch
.pending_exceptions
) {
286 kvm_vcpu_block(vcpu
);
288 /* We we are runnable, then definitely go off to user space to check if any
289 * I/O interrupts are pending.
291 if (kvm_check_request(KVM_REQ_UNHALT
, vcpu
)) {
292 clear_bit(KVM_REQ_UNHALT
, &vcpu
->requests
);
293 vcpu
->run
->exit_reason
= KVM_EXIT_IRQ_WINDOW_OPEN
;
300 /* XXXKYMA: Linux doesn't seem to use TLBR, return EMULATE_FAIL for now so that we can catch
301 * this, if things ever change
303 enum emulation_result
kvm_mips_emul_tlbr(struct kvm_vcpu
*vcpu
)
305 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
306 enum emulation_result er
= EMULATE_FAIL
;
307 uint32_t pc
= vcpu
->arch
.pc
;
309 printk("[%#x] COP0_TLBR [%ld]\n", pc
, kvm_read_c0_guest_index(cop0
));
313 /* Write Guest TLB Entry @ Index */
314 enum emulation_result
kvm_mips_emul_tlbwi(struct kvm_vcpu
*vcpu
)
316 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
317 int index
= kvm_read_c0_guest_index(cop0
);
318 enum emulation_result er
= EMULATE_DONE
;
319 struct kvm_mips_tlb
*tlb
= NULL
;
320 uint32_t pc
= vcpu
->arch
.pc
;
322 if (index
< 0 || index
>= KVM_MIPS_GUEST_TLB_SIZE
) {
323 printk("%s: illegal index: %d\n", __func__
, index
);
325 ("[%#x] COP0_TLBWI [%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx, mask: %#lx)\n",
326 pc
, index
, kvm_read_c0_guest_entryhi(cop0
),
327 kvm_read_c0_guest_entrylo0(cop0
),
328 kvm_read_c0_guest_entrylo1(cop0
),
329 kvm_read_c0_guest_pagemask(cop0
));
330 index
= (index
& ~0x80000000) % KVM_MIPS_GUEST_TLB_SIZE
;
333 tlb
= &vcpu
->arch
.guest_tlb
[index
];
335 /* Probe the shadow host TLB for the entry being overwritten, if one matches, invalidate it */
336 kvm_mips_host_tlb_inv(vcpu
, tlb
->tlb_hi
);
339 tlb
->tlb_mask
= kvm_read_c0_guest_pagemask(cop0
);
340 tlb
->tlb_hi
= kvm_read_c0_guest_entryhi(cop0
);
341 tlb
->tlb_lo0
= kvm_read_c0_guest_entrylo0(cop0
);
342 tlb
->tlb_lo1
= kvm_read_c0_guest_entrylo1(cop0
);
345 ("[%#x] COP0_TLBWI [%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx, mask: %#lx)\n",
346 pc
, index
, kvm_read_c0_guest_entryhi(cop0
),
347 kvm_read_c0_guest_entrylo0(cop0
), kvm_read_c0_guest_entrylo1(cop0
),
348 kvm_read_c0_guest_pagemask(cop0
));
353 /* Write Guest TLB Entry @ Random Index */
354 enum emulation_result
kvm_mips_emul_tlbwr(struct kvm_vcpu
*vcpu
)
356 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
357 enum emulation_result er
= EMULATE_DONE
;
358 struct kvm_mips_tlb
*tlb
= NULL
;
359 uint32_t pc
= vcpu
->arch
.pc
;
363 get_random_bytes(&index
, sizeof(index
));
364 index
&= (KVM_MIPS_GUEST_TLB_SIZE
- 1);
366 index
= jiffies
% KVM_MIPS_GUEST_TLB_SIZE
;
369 if (index
< 0 || index
>= KVM_MIPS_GUEST_TLB_SIZE
) {
370 printk("%s: illegal index: %d\n", __func__
, index
);
374 tlb
= &vcpu
->arch
.guest_tlb
[index
];
377 /* Probe the shadow host TLB for the entry being overwritten, if one matches, invalidate it */
378 kvm_mips_host_tlb_inv(vcpu
, tlb
->tlb_hi
);
381 tlb
->tlb_mask
= kvm_read_c0_guest_pagemask(cop0
);
382 tlb
->tlb_hi
= kvm_read_c0_guest_entryhi(cop0
);
383 tlb
->tlb_lo0
= kvm_read_c0_guest_entrylo0(cop0
);
384 tlb
->tlb_lo1
= kvm_read_c0_guest_entrylo1(cop0
);
387 ("[%#x] COP0_TLBWR[%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx)\n",
388 pc
, index
, kvm_read_c0_guest_entryhi(cop0
),
389 kvm_read_c0_guest_entrylo0(cop0
),
390 kvm_read_c0_guest_entrylo1(cop0
));
395 enum emulation_result
kvm_mips_emul_tlbp(struct kvm_vcpu
*vcpu
)
397 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
398 long entryhi
= kvm_read_c0_guest_entryhi(cop0
);
399 enum emulation_result er
= EMULATE_DONE
;
400 uint32_t pc
= vcpu
->arch
.pc
;
403 index
= kvm_mips_guest_tlb_lookup(vcpu
, entryhi
);
405 kvm_write_c0_guest_index(cop0
, index
);
407 kvm_debug("[%#x] COP0_TLBP (entryhi: %#lx), index: %d\n", pc
, entryhi
,
413 enum emulation_result
414 kvm_mips_emulate_CP0(uint32_t inst
, uint32_t *opc
, uint32_t cause
,
415 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
417 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
418 enum emulation_result er
= EMULATE_DONE
;
419 int32_t rt
, rd
, copz
, sel
, co_bit
, op
;
420 uint32_t pc
= vcpu
->arch
.pc
;
421 unsigned long curr_pc
;
424 * Update PC and hold onto current PC in case there is
425 * an error and we want to rollback the PC
427 curr_pc
= vcpu
->arch
.pc
;
428 er
= update_pc(vcpu
, cause
);
429 if (er
== EMULATE_FAIL
) {
433 copz
= (inst
>> 21) & 0x1f;
434 rt
= (inst
>> 16) & 0x1f;
435 rd
= (inst
>> 11) & 0x1f;
437 co_bit
= (inst
>> 25) & 1;
439 /* Verify that the register is valid */
440 if (rd
> MIPS_CP0_DESAVE
) {
441 printk("Invalid rd: %d\n", rd
);
450 case tlbr_op
: /* Read indexed TLB entry */
451 er
= kvm_mips_emul_tlbr(vcpu
);
453 case tlbwi_op
: /* Write indexed */
454 er
= kvm_mips_emul_tlbwi(vcpu
);
456 case tlbwr_op
: /* Write random */
457 er
= kvm_mips_emul_tlbwr(vcpu
);
459 case tlbp_op
: /* TLB Probe */
460 er
= kvm_mips_emul_tlbp(vcpu
);
463 printk("!!!COP0_RFE!!!\n");
466 er
= kvm_mips_emul_eret(vcpu
);
470 er
= kvm_mips_emul_wait(vcpu
);
476 #ifdef CONFIG_KVM_MIPS_DEBUG_COP0_COUNTERS
477 cop0
->stat
[rd
][sel
]++;
480 if ((rd
== MIPS_CP0_COUNT
) && (sel
== 0)) {
481 /* XXXKYMA: Run the Guest count register @ 1/4 the rate of the host */
482 vcpu
->arch
.gprs
[rt
] = (read_c0_count() >> 2);
483 } else if ((rd
== MIPS_CP0_ERRCTL
) && (sel
== 0)) {
484 vcpu
->arch
.gprs
[rt
] = 0x0;
485 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
486 kvm_mips_trans_mfc0(inst
, opc
, vcpu
);
490 vcpu
->arch
.gprs
[rt
] = cop0
->reg
[rd
][sel
];
492 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
493 kvm_mips_trans_mfc0(inst
, opc
, vcpu
);
498 ("[%#x] MFCz[%d][%d], vcpu->arch.gprs[%d]: %#lx\n",
499 pc
, rd
, sel
, rt
, vcpu
->arch
.gprs
[rt
]);
504 vcpu
->arch
.gprs
[rt
] = cop0
->reg
[rd
][sel
];
508 #ifdef CONFIG_KVM_MIPS_DEBUG_COP0_COUNTERS
509 cop0
->stat
[rd
][sel
]++;
511 if ((rd
== MIPS_CP0_TLB_INDEX
)
512 && (vcpu
->arch
.gprs
[rt
] >=
513 KVM_MIPS_GUEST_TLB_SIZE
)) {
514 printk("Invalid TLB Index: %ld",
515 vcpu
->arch
.gprs
[rt
]);
519 #define C0_EBASE_CORE_MASK 0xff
520 if ((rd
== MIPS_CP0_PRID
) && (sel
== 1)) {
521 /* Preserve CORE number */
522 kvm_change_c0_guest_ebase(cop0
,
523 ~(C0_EBASE_CORE_MASK
),
524 vcpu
->arch
.gprs
[rt
]);
525 printk("MTCz, cop0->reg[EBASE]: %#lx\n",
526 kvm_read_c0_guest_ebase(cop0
));
527 } else if (rd
== MIPS_CP0_TLB_HI
&& sel
== 0) {
528 uint32_t nasid
= ASID_MASK(vcpu
->arch
.gprs
[rt
]);
529 if ((KSEGX(vcpu
->arch
.gprs
[rt
]) != CKSEG0
)
531 (ASID_MASK(kvm_read_c0_guest_entryhi(cop0
))
535 ("MTCz, change ASID from %#lx to %#lx\n",
536 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
)),
537 ASID_MASK(vcpu
->arch
.gprs
[rt
]));
539 /* Blow away the shadow host TLBs */
540 kvm_mips_flush_host_tlb(1);
542 kvm_write_c0_guest_entryhi(cop0
,
543 vcpu
->arch
.gprs
[rt
]);
545 /* Are we writing to COUNT */
546 else if ((rd
== MIPS_CP0_COUNT
) && (sel
== 0)) {
547 /* Linux doesn't seem to write into COUNT, we throw an error
548 * if we notice a write to COUNT
550 /*er = EMULATE_FAIL; */
552 } else if ((rd
== MIPS_CP0_COMPARE
) && (sel
== 0)) {
553 kvm_debug("[%#x] MTCz, COMPARE %#lx <- %#lx\n",
554 pc
, kvm_read_c0_guest_compare(cop0
),
555 vcpu
->arch
.gprs
[rt
]);
557 /* If we are writing to COMPARE */
558 /* Clear pending timer interrupt, if any */
559 kvm_mips_callbacks
->dequeue_timer_int(vcpu
);
560 kvm_write_c0_guest_compare(cop0
,
561 vcpu
->arch
.gprs
[rt
]);
562 } else if ((rd
== MIPS_CP0_STATUS
) && (sel
== 0)) {
563 kvm_write_c0_guest_status(cop0
,
564 vcpu
->arch
.gprs
[rt
]);
565 /* Make sure that CU1 and NMI bits are never set */
566 kvm_clear_c0_guest_status(cop0
,
567 (ST0_CU1
| ST0_NMI
));
569 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
570 kvm_mips_trans_mtc0(inst
, opc
, vcpu
);
573 cop0
->reg
[rd
][sel
] = vcpu
->arch
.gprs
[rt
];
574 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
575 kvm_mips_trans_mtc0(inst
, opc
, vcpu
);
579 kvm_debug("[%#x] MTCz, cop0->reg[%d][%d]: %#lx\n", pc
,
580 rd
, sel
, cop0
->reg
[rd
][sel
]);
585 ("!!!!!!![%#lx]dmtc_op: rt: %d, rd: %d, sel: %d!!!!!!\n",
586 vcpu
->arch
.pc
, rt
, rd
, sel
);
591 #ifdef KVM_MIPS_DEBUG_COP0_COUNTERS
592 cop0
->stat
[MIPS_CP0_STATUS
][0]++;
595 vcpu
->arch
.gprs
[rt
] =
596 kvm_read_c0_guest_status(cop0
);
600 kvm_debug("[%#lx] mfmcz_op: EI\n",
602 kvm_set_c0_guest_status(cop0
, ST0_IE
);
604 kvm_debug("[%#lx] mfmcz_op: DI\n",
606 kvm_clear_c0_guest_status(cop0
, ST0_IE
);
614 cop0
->reg
[MIPS_CP0_STATUS
][2] & 0xf;
616 (cop0
->reg
[MIPS_CP0_STATUS
][2] >> 6) & 0xf;
617 /* We don't support any shadow register sets, so SRSCtl[PSS] == SRSCtl[CSS] = 0 */
622 kvm_debug("WRPGPR[%d][%d] = %#lx\n", pss
, rd
,
623 vcpu
->arch
.gprs
[rt
]);
624 vcpu
->arch
.gprs
[rd
] = vcpu
->arch
.gprs
[rt
];
629 ("[%#lx]MachEmulateCP0: unsupported COP0, copz: 0x%x\n",
630 vcpu
->arch
.pc
, copz
);
638 * Rollback PC only if emulation was unsuccessful
640 if (er
== EMULATE_FAIL
) {
641 vcpu
->arch
.pc
= curr_pc
;
646 * This is for special instructions whose emulation
647 * updates the PC, so do not overwrite the PC under
654 enum emulation_result
655 kvm_mips_emulate_store(uint32_t inst
, uint32_t cause
,
656 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
658 enum emulation_result er
= EMULATE_DO_MMIO
;
659 int32_t op
, base
, rt
, offset
;
661 void *data
= run
->mmio
.data
;
662 unsigned long curr_pc
;
665 * Update PC and hold onto current PC in case there is
666 * an error and we want to rollback the PC
668 curr_pc
= vcpu
->arch
.pc
;
669 er
= update_pc(vcpu
, cause
);
670 if (er
== EMULATE_FAIL
)
673 rt
= (inst
>> 16) & 0x1f;
674 base
= (inst
>> 21) & 0x1f;
675 offset
= inst
& 0xffff;
676 op
= (inst
>> 26) & 0x3f;
681 if (bytes
> sizeof(run
->mmio
.data
)) {
682 kvm_err("%s: bad MMIO length: %d\n", __func__
,
685 run
->mmio
.phys_addr
=
686 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
688 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
692 run
->mmio
.len
= bytes
;
693 run
->mmio
.is_write
= 1;
694 vcpu
->mmio_needed
= 1;
695 vcpu
->mmio_is_write
= 1;
696 *(u8
*) data
= vcpu
->arch
.gprs
[rt
];
697 kvm_debug("OP_SB: eaddr: %#lx, gpr: %#lx, data: %#x\n",
698 vcpu
->arch
.host_cp0_badvaddr
, vcpu
->arch
.gprs
[rt
],
705 if (bytes
> sizeof(run
->mmio
.data
)) {
706 kvm_err("%s: bad MMIO length: %d\n", __func__
,
709 run
->mmio
.phys_addr
=
710 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
712 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
717 run
->mmio
.len
= bytes
;
718 run
->mmio
.is_write
= 1;
719 vcpu
->mmio_needed
= 1;
720 vcpu
->mmio_is_write
= 1;
721 *(uint32_t *) data
= vcpu
->arch
.gprs
[rt
];
723 kvm_debug("[%#lx] OP_SW: eaddr: %#lx, gpr: %#lx, data: %#x\n",
724 vcpu
->arch
.pc
, vcpu
->arch
.host_cp0_badvaddr
,
725 vcpu
->arch
.gprs
[rt
], *(uint32_t *) data
);
730 if (bytes
> sizeof(run
->mmio
.data
)) {
731 kvm_err("%s: bad MMIO length: %d\n", __func__
,
734 run
->mmio
.phys_addr
=
735 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
737 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
742 run
->mmio
.len
= bytes
;
743 run
->mmio
.is_write
= 1;
744 vcpu
->mmio_needed
= 1;
745 vcpu
->mmio_is_write
= 1;
746 *(uint16_t *) data
= vcpu
->arch
.gprs
[rt
];
748 kvm_debug("[%#lx] OP_SH: eaddr: %#lx, gpr: %#lx, data: %#x\n",
749 vcpu
->arch
.pc
, vcpu
->arch
.host_cp0_badvaddr
,
750 vcpu
->arch
.gprs
[rt
], *(uint32_t *) data
);
754 printk("Store not yet supported");
760 * Rollback PC if emulation was unsuccessful
762 if (er
== EMULATE_FAIL
) {
763 vcpu
->arch
.pc
= curr_pc
;
769 enum emulation_result
770 kvm_mips_emulate_load(uint32_t inst
, uint32_t cause
,
771 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
773 enum emulation_result er
= EMULATE_DO_MMIO
;
774 int32_t op
, base
, rt
, offset
;
777 rt
= (inst
>> 16) & 0x1f;
778 base
= (inst
>> 21) & 0x1f;
779 offset
= inst
& 0xffff;
780 op
= (inst
>> 26) & 0x3f;
782 vcpu
->arch
.pending_load_cause
= cause
;
783 vcpu
->arch
.io_gpr
= rt
;
788 if (bytes
> sizeof(run
->mmio
.data
)) {
789 kvm_err("%s: bad MMIO length: %d\n", __func__
,
794 run
->mmio
.phys_addr
=
795 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
797 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
802 run
->mmio
.len
= bytes
;
803 run
->mmio
.is_write
= 0;
804 vcpu
->mmio_needed
= 1;
805 vcpu
->mmio_is_write
= 0;
811 if (bytes
> sizeof(run
->mmio
.data
)) {
812 kvm_err("%s: bad MMIO length: %d\n", __func__
,
817 run
->mmio
.phys_addr
=
818 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
820 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
825 run
->mmio
.len
= bytes
;
826 run
->mmio
.is_write
= 0;
827 vcpu
->mmio_needed
= 1;
828 vcpu
->mmio_is_write
= 0;
831 vcpu
->mmio_needed
= 2;
833 vcpu
->mmio_needed
= 1;
840 if (bytes
> sizeof(run
->mmio
.data
)) {
841 kvm_err("%s: bad MMIO length: %d\n", __func__
,
846 run
->mmio
.phys_addr
=
847 kvm_mips_callbacks
->gva_to_gpa(vcpu
->arch
.
849 if (run
->mmio
.phys_addr
== KVM_INVALID_ADDR
) {
854 run
->mmio
.len
= bytes
;
855 run
->mmio
.is_write
= 0;
856 vcpu
->mmio_is_write
= 0;
859 vcpu
->mmio_needed
= 2;
861 vcpu
->mmio_needed
= 1;
866 printk("Load not yet supported");
874 int kvm_mips_sync_icache(unsigned long va
, struct kvm_vcpu
*vcpu
)
876 unsigned long offset
= (va
& ~PAGE_MASK
);
877 struct kvm
*kvm
= vcpu
->kvm
;
882 gfn
= va
>> PAGE_SHIFT
;
884 if (gfn
>= kvm
->arch
.guest_pmap_npages
) {
885 printk("%s: Invalid gfn: %#llx\n", __func__
, gfn
);
886 kvm_mips_dump_host_tlbs();
887 kvm_arch_vcpu_dump_regs(vcpu
);
890 pfn
= kvm
->arch
.guest_pmap
[gfn
];
891 pa
= (pfn
<< PAGE_SHIFT
) | offset
;
893 printk("%s: va: %#lx, unmapped: %#x\n", __func__
, va
, CKSEG0ADDR(pa
));
895 mips32_SyncICache(CKSEG0ADDR(pa
), 32);
899 #define MIPS_CACHE_OP_INDEX_INV 0x0
900 #define MIPS_CACHE_OP_INDEX_LD_TAG 0x1
901 #define MIPS_CACHE_OP_INDEX_ST_TAG 0x2
902 #define MIPS_CACHE_OP_IMP 0x3
903 #define MIPS_CACHE_OP_HIT_INV 0x4
904 #define MIPS_CACHE_OP_FILL_WB_INV 0x5
905 #define MIPS_CACHE_OP_HIT_HB 0x6
906 #define MIPS_CACHE_OP_FETCH_LOCK 0x7
908 #define MIPS_CACHE_ICACHE 0x0
909 #define MIPS_CACHE_DCACHE 0x1
910 #define MIPS_CACHE_SEC 0x3
912 enum emulation_result
913 kvm_mips_emulate_cache(uint32_t inst
, uint32_t *opc
, uint32_t cause
,
914 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
916 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
917 extern void (*r4k_blast_dcache
) (void);
918 extern void (*r4k_blast_icache
) (void);
919 enum emulation_result er
= EMULATE_DONE
;
920 int32_t offset
, cache
, op_inst
, op
, base
;
921 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
923 unsigned long curr_pc
;
926 * Update PC and hold onto current PC in case there is
927 * an error and we want to rollback the PC
929 curr_pc
= vcpu
->arch
.pc
;
930 er
= update_pc(vcpu
, cause
);
931 if (er
== EMULATE_FAIL
)
934 base
= (inst
>> 21) & 0x1f;
935 op_inst
= (inst
>> 16) & 0x1f;
936 offset
= inst
& 0xffff;
937 cache
= (inst
>> 16) & 0x3;
938 op
= (inst
>> 18) & 0x7;
940 va
= arch
->gprs
[base
] + offset
;
942 kvm_debug("CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
943 cache
, op
, base
, arch
->gprs
[base
], offset
);
945 /* Treat INDEX_INV as a nop, basically issued by Linux on startup to invalidate
946 * the caches entirely by stepping through all the ways/indexes
948 if (op
== MIPS_CACHE_OP_INDEX_INV
) {
950 ("@ %#lx/%#lx CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
951 vcpu
->arch
.pc
, vcpu
->arch
.gprs
[31], cache
, op
, base
,
952 arch
->gprs
[base
], offset
);
954 if (cache
== MIPS_CACHE_DCACHE
)
956 else if (cache
== MIPS_CACHE_ICACHE
)
959 printk("%s: unsupported CACHE INDEX operation\n",
964 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
965 kvm_mips_trans_cache_index(inst
, opc
, vcpu
);
971 if (KVM_GUEST_KSEGX(va
) == KVM_GUEST_KSEG0
) {
973 if (kvm_mips_host_tlb_lookup(vcpu
, va
) < 0) {
974 kvm_mips_handle_kseg0_tlb_fault(va
, vcpu
);
976 } else if ((KVM_GUEST_KSEGX(va
) < KVM_GUEST_KSEG0
) ||
977 KVM_GUEST_KSEGX(va
) == KVM_GUEST_KSEG23
) {
980 /* If an entry already exists then skip */
981 if (kvm_mips_host_tlb_lookup(vcpu
, va
) >= 0) {
985 /* If address not in the guest TLB, then give the guest a fault, the
986 * resulting handler will do the right thing
988 index
= kvm_mips_guest_tlb_lookup(vcpu
, (va
& VPN2_MASK
) |
989 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
)));
992 vcpu
->arch
.host_cp0_entryhi
= (va
& VPN2_MASK
);
993 vcpu
->arch
.host_cp0_badvaddr
= va
;
994 er
= kvm_mips_emulate_tlbmiss_ld(cause
, NULL
, run
,
999 struct kvm_mips_tlb
*tlb
= &vcpu
->arch
.guest_tlb
[index
];
1000 /* Check if the entry is valid, if not then setup a TLB invalid exception to the guest */
1001 if (!TLB_IS_VALID(*tlb
, va
)) {
1002 er
= kvm_mips_emulate_tlbinv_ld(cause
, NULL
,
1005 goto dont_update_pc
;
1007 /* We fault an entry from the guest tlb to the shadow host TLB */
1008 kvm_mips_handle_mapped_seg_tlb_fault(vcpu
, tlb
,
1015 ("INVALID CACHE INDEX/ADDRESS (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1016 cache
, op
, base
, arch
->gprs
[base
], offset
);
1019 goto dont_update_pc
;
1024 /* XXXKYMA: Only a subset of cache ops are supported, used by Linux */
1025 if (cache
== MIPS_CACHE_DCACHE
1026 && (op
== MIPS_CACHE_OP_FILL_WB_INV
1027 || op
== MIPS_CACHE_OP_HIT_INV
)) {
1028 flush_dcache_line(va
);
1030 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1031 /* Replace the CACHE instruction, with a SYNCI, not the same, but avoids a trap */
1032 kvm_mips_trans_cache_va(inst
, opc
, vcpu
);
1034 } else if (op
== MIPS_CACHE_OP_HIT_INV
&& cache
== MIPS_CACHE_ICACHE
) {
1035 flush_dcache_line(va
);
1036 flush_icache_line(va
);
1038 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1039 /* Replace the CACHE instruction, with a SYNCI */
1040 kvm_mips_trans_cache_va(inst
, opc
, vcpu
);
1044 ("NO-OP CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1045 cache
, op
, base
, arch
->gprs
[base
], offset
);
1048 goto dont_update_pc
;
1057 vcpu
->arch
.pc
= curr_pc
;
1062 enum emulation_result
1063 kvm_mips_emulate_inst(unsigned long cause
, uint32_t *opc
,
1064 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1066 enum emulation_result er
= EMULATE_DONE
;
1070 * Fetch the instruction.
1072 if (cause
& CAUSEF_BD
) {
1076 inst
= kvm_get_inst(opc
, vcpu
);
1078 switch (((union mips_instruction
)inst
).r_format
.opcode
) {
1080 er
= kvm_mips_emulate_CP0(inst
, opc
, cause
, run
, vcpu
);
1085 er
= kvm_mips_emulate_store(inst
, cause
, run
, vcpu
);
1092 er
= kvm_mips_emulate_load(inst
, cause
, run
, vcpu
);
1096 ++vcpu
->stat
.cache_exits
;
1097 trace_kvm_exit(vcpu
, CACHE_EXITS
);
1098 er
= kvm_mips_emulate_cache(inst
, opc
, cause
, run
, vcpu
);
1102 printk("Instruction emulation not supported (%p/%#x)\n", opc
,
1104 kvm_arch_vcpu_dump_regs(vcpu
);
1112 enum emulation_result
1113 kvm_mips_emulate_syscall(unsigned long cause
, uint32_t *opc
,
1114 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1116 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1117 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1118 enum emulation_result er
= EMULATE_DONE
;
1120 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1122 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1123 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1125 if (cause
& CAUSEF_BD
)
1126 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1128 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1130 kvm_debug("Delivering SYSCALL @ pc %#lx\n", arch
->pc
);
1132 kvm_change_c0_guest_cause(cop0
, (0xff),
1133 (T_SYSCALL
<< CAUSEB_EXCCODE
));
1135 /* Set PC to the exception entry point */
1136 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1139 printk("Trying to deliver SYSCALL when EXL is already set\n");
1146 enum emulation_result
1147 kvm_mips_emulate_tlbmiss_ld(unsigned long cause
, uint32_t *opc
,
1148 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1150 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1151 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1152 enum emulation_result er
= EMULATE_DONE
;
1153 unsigned long entryhi
= (vcpu
->arch
. host_cp0_badvaddr
& VPN2_MASK
) |
1154 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
));
1156 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1158 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1159 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1161 if (cause
& CAUSEF_BD
)
1162 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1164 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1166 kvm_debug("[EXL == 0] delivering TLB MISS @ pc %#lx\n",
1169 /* set pc to the exception entry point */
1170 arch
->pc
= KVM_GUEST_KSEG0
+ 0x0;
1173 kvm_debug("[EXL == 1] delivering TLB MISS @ pc %#lx\n",
1176 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1179 kvm_change_c0_guest_cause(cop0
, (0xff),
1180 (T_TLB_LD_MISS
<< CAUSEB_EXCCODE
));
1182 /* setup badvaddr, context and entryhi registers for the guest */
1183 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1184 /* XXXKYMA: is the context register used by linux??? */
1185 kvm_write_c0_guest_entryhi(cop0
, entryhi
);
1186 /* Blow away the shadow host TLBs */
1187 kvm_mips_flush_host_tlb(1);
1192 enum emulation_result
1193 kvm_mips_emulate_tlbinv_ld(unsigned long cause
, uint32_t *opc
,
1194 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1196 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1197 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1198 enum emulation_result er
= EMULATE_DONE
;
1199 unsigned long entryhi
=
1200 (vcpu
->arch
.host_cp0_badvaddr
& VPN2_MASK
) |
1201 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
));
1203 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1205 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1206 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1208 if (cause
& CAUSEF_BD
)
1209 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1211 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1213 kvm_debug("[EXL == 0] delivering TLB INV @ pc %#lx\n",
1216 /* set pc to the exception entry point */
1217 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1220 kvm_debug("[EXL == 1] delivering TLB MISS @ pc %#lx\n",
1222 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1225 kvm_change_c0_guest_cause(cop0
, (0xff),
1226 (T_TLB_LD_MISS
<< CAUSEB_EXCCODE
));
1228 /* setup badvaddr, context and entryhi registers for the guest */
1229 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1230 /* XXXKYMA: is the context register used by linux??? */
1231 kvm_write_c0_guest_entryhi(cop0
, entryhi
);
1232 /* Blow away the shadow host TLBs */
1233 kvm_mips_flush_host_tlb(1);
1238 enum emulation_result
1239 kvm_mips_emulate_tlbmiss_st(unsigned long cause
, uint32_t *opc
,
1240 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1242 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1243 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1244 enum emulation_result er
= EMULATE_DONE
;
1245 unsigned long entryhi
= (vcpu
->arch
.host_cp0_badvaddr
& VPN2_MASK
) |
1246 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
));
1248 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1250 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1251 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1253 if (cause
& CAUSEF_BD
)
1254 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1256 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1258 kvm_debug("[EXL == 0] Delivering TLB MISS @ pc %#lx\n",
1261 /* Set PC to the exception entry point */
1262 arch
->pc
= KVM_GUEST_KSEG0
+ 0x0;
1264 kvm_debug("[EXL == 1] Delivering TLB MISS @ pc %#lx\n",
1266 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1269 kvm_change_c0_guest_cause(cop0
, (0xff),
1270 (T_TLB_ST_MISS
<< CAUSEB_EXCCODE
));
1272 /* setup badvaddr, context and entryhi registers for the guest */
1273 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1274 /* XXXKYMA: is the context register used by linux??? */
1275 kvm_write_c0_guest_entryhi(cop0
, entryhi
);
1276 /* Blow away the shadow host TLBs */
1277 kvm_mips_flush_host_tlb(1);
1282 enum emulation_result
1283 kvm_mips_emulate_tlbinv_st(unsigned long cause
, uint32_t *opc
,
1284 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1286 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1287 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1288 enum emulation_result er
= EMULATE_DONE
;
1289 unsigned long entryhi
= (vcpu
->arch
.host_cp0_badvaddr
& VPN2_MASK
) |
1290 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
));
1292 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1294 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1295 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1297 if (cause
& CAUSEF_BD
)
1298 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1300 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1302 kvm_debug("[EXL == 0] Delivering TLB MISS @ pc %#lx\n",
1305 /* Set PC to the exception entry point */
1306 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1308 kvm_debug("[EXL == 1] Delivering TLB MISS @ pc %#lx\n",
1310 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1313 kvm_change_c0_guest_cause(cop0
, (0xff),
1314 (T_TLB_ST_MISS
<< CAUSEB_EXCCODE
));
1316 /* setup badvaddr, context and entryhi registers for the guest */
1317 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1318 /* XXXKYMA: is the context register used by linux??? */
1319 kvm_write_c0_guest_entryhi(cop0
, entryhi
);
1320 /* Blow away the shadow host TLBs */
1321 kvm_mips_flush_host_tlb(1);
1326 /* TLBMOD: store into address matching TLB with Dirty bit off */
1327 enum emulation_result
1328 kvm_mips_handle_tlbmod(unsigned long cause
, uint32_t *opc
,
1329 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1331 enum emulation_result er
= EMULATE_DONE
;
1335 * If address not in the guest TLB, then we are in trouble
1337 index
= kvm_mips_guest_tlb_lookup(vcpu
, entryhi
);
1339 /* XXXKYMA Invalidate and retry */
1340 kvm_mips_host_tlb_inv(vcpu
, vcpu
->arch
.host_cp0_badvaddr
);
1341 kvm_err("%s: host got TLBMOD for %#lx but entry not present in Guest TLB\n",
1343 kvm_mips_dump_guest_tlbs(vcpu
);
1344 kvm_mips_dump_host_tlbs();
1345 return EMULATE_FAIL
;
1349 er
= kvm_mips_emulate_tlbmod(cause
, opc
, run
, vcpu
);
1353 enum emulation_result
1354 kvm_mips_emulate_tlbmod(unsigned long cause
, uint32_t *opc
,
1355 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1357 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1358 unsigned long entryhi
= (vcpu
->arch
.host_cp0_badvaddr
& VPN2_MASK
) |
1359 ASID_MASK(kvm_read_c0_guest_entryhi(cop0
));
1360 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1361 enum emulation_result er
= EMULATE_DONE
;
1363 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1365 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1366 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1368 if (cause
& CAUSEF_BD
)
1369 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1371 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1373 kvm_debug("[EXL == 0] Delivering TLB MOD @ pc %#lx\n",
1376 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1378 kvm_debug("[EXL == 1] Delivering TLB MOD @ pc %#lx\n",
1380 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1383 kvm_change_c0_guest_cause(cop0
, (0xff), (T_TLB_MOD
<< CAUSEB_EXCCODE
));
1385 /* setup badvaddr, context and entryhi registers for the guest */
1386 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1387 /* XXXKYMA: is the context register used by linux??? */
1388 kvm_write_c0_guest_entryhi(cop0
, entryhi
);
1389 /* Blow away the shadow host TLBs */
1390 kvm_mips_flush_host_tlb(1);
1395 enum emulation_result
1396 kvm_mips_emulate_fpu_exc(unsigned long cause
, uint32_t *opc
,
1397 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1399 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1400 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1401 enum emulation_result er
= EMULATE_DONE
;
1403 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1405 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1406 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1408 if (cause
& CAUSEF_BD
)
1409 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1411 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1415 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1417 kvm_change_c0_guest_cause(cop0
, (0xff),
1418 (T_COP_UNUSABLE
<< CAUSEB_EXCCODE
));
1419 kvm_change_c0_guest_cause(cop0
, (CAUSEF_CE
), (0x1 << CAUSEB_CE
));
1424 enum emulation_result
1425 kvm_mips_emulate_ri_exc(unsigned long cause
, uint32_t *opc
,
1426 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1428 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1429 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1430 enum emulation_result er
= EMULATE_DONE
;
1432 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1434 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1435 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1437 if (cause
& CAUSEF_BD
)
1438 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1440 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1442 kvm_debug("Delivering RI @ pc %#lx\n", arch
->pc
);
1444 kvm_change_c0_guest_cause(cop0
, (0xff),
1445 (T_RES_INST
<< CAUSEB_EXCCODE
));
1447 /* Set PC to the exception entry point */
1448 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1451 kvm_err("Trying to deliver RI when EXL is already set\n");
1458 enum emulation_result
1459 kvm_mips_emulate_bp_exc(unsigned long cause
, uint32_t *opc
,
1460 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1462 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1463 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1464 enum emulation_result er
= EMULATE_DONE
;
1466 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1468 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1469 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1471 if (cause
& CAUSEF_BD
)
1472 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1474 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1476 kvm_debug("Delivering BP @ pc %#lx\n", arch
->pc
);
1478 kvm_change_c0_guest_cause(cop0
, (0xff),
1479 (T_BREAK
<< CAUSEB_EXCCODE
));
1481 /* Set PC to the exception entry point */
1482 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1485 printk("Trying to deliver BP when EXL is already set\n");
1493 * ll/sc, rdhwr, sync emulation
1496 #define OPCODE 0xfc000000
1497 #define BASE 0x03e00000
1498 #define RT 0x001f0000
1499 #define OFFSET 0x0000ffff
1500 #define LL 0xc0000000
1501 #define SC 0xe0000000
1502 #define SPEC0 0x00000000
1503 #define SPEC3 0x7c000000
1504 #define RD 0x0000f800
1505 #define FUNC 0x0000003f
1506 #define SYNC 0x0000000f
1507 #define RDHWR 0x0000003b
1509 enum emulation_result
1510 kvm_mips_handle_ri(unsigned long cause
, uint32_t *opc
,
1511 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1513 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1514 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1515 enum emulation_result er
= EMULATE_DONE
;
1516 unsigned long curr_pc
;
1520 * Update PC and hold onto current PC in case there is
1521 * an error and we want to rollback the PC
1523 curr_pc
= vcpu
->arch
.pc
;
1524 er
= update_pc(vcpu
, cause
);
1525 if (er
== EMULATE_FAIL
)
1529 * Fetch the instruction.
1531 if (cause
& CAUSEF_BD
)
1534 inst
= kvm_get_inst(opc
, vcpu
);
1536 if (inst
== KVM_INVALID_INST
) {
1537 printk("%s: Cannot get inst @ %p\n", __func__
, opc
);
1538 return EMULATE_FAIL
;
1541 if ((inst
& OPCODE
) == SPEC3
&& (inst
& FUNC
) == RDHWR
) {
1542 int rd
= (inst
& RD
) >> 11;
1543 int rt
= (inst
& RT
) >> 16;
1545 case 0: /* CPU number */
1548 case 1: /* SYNCI length */
1549 arch
->gprs
[rt
] = min(current_cpu_data
.dcache
.linesz
,
1550 current_cpu_data
.icache
.linesz
);
1552 case 2: /* Read count register */
1553 printk("RDHWR: Cont register\n");
1554 arch
->gprs
[rt
] = kvm_read_c0_guest_count(cop0
);
1556 case 3: /* Count register resolution */
1557 switch (current_cpu_data
.cputype
) {
1568 arch
->gprs
[rt
] = kvm_read_c0_guest_userlocal(cop0
);
1570 /* UserLocal not implemented */
1571 er
= kvm_mips_emulate_ri_exc(cause
, opc
, run
, vcpu
);
1576 printk("RDHWR not supported\n");
1581 printk("Emulate RI not supported @ %p: %#x\n", opc
, inst
);
1586 * Rollback PC only if emulation was unsuccessful
1588 if (er
== EMULATE_FAIL
) {
1589 vcpu
->arch
.pc
= curr_pc
;
1594 enum emulation_result
1595 kvm_mips_complete_mmio_load(struct kvm_vcpu
*vcpu
, struct kvm_run
*run
)
1597 unsigned long *gpr
= &vcpu
->arch
.gprs
[vcpu
->arch
.io_gpr
];
1598 enum emulation_result er
= EMULATE_DONE
;
1599 unsigned long curr_pc
;
1601 if (run
->mmio
.len
> sizeof(*gpr
)) {
1602 printk("Bad MMIO length: %d", run
->mmio
.len
);
1608 * Update PC and hold onto current PC in case there is
1609 * an error and we want to rollback the PC
1611 curr_pc
= vcpu
->arch
.pc
;
1612 er
= update_pc(vcpu
, vcpu
->arch
.pending_load_cause
);
1613 if (er
== EMULATE_FAIL
)
1616 switch (run
->mmio
.len
) {
1618 *gpr
= *(int32_t *) run
->mmio
.data
;
1622 if (vcpu
->mmio_needed
== 2)
1623 *gpr
= *(int16_t *) run
->mmio
.data
;
1625 *gpr
= *(int16_t *) run
->mmio
.data
;
1629 if (vcpu
->mmio_needed
== 2)
1630 *gpr
= *(int8_t *) run
->mmio
.data
;
1632 *gpr
= *(u8
*) run
->mmio
.data
;
1636 if (vcpu
->arch
.pending_load_cause
& CAUSEF_BD
)
1638 ("[%#lx] Completing %d byte BD Load to gpr %d (0x%08lx) type %d\n",
1639 vcpu
->arch
.pc
, run
->mmio
.len
, vcpu
->arch
.io_gpr
, *gpr
,
1646 static enum emulation_result
1647 kvm_mips_emulate_exc(unsigned long cause
, uint32_t *opc
,
1648 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1650 uint32_t exccode
= (cause
>> CAUSEB_EXCCODE
) & 0x1f;
1651 struct mips_coproc
*cop0
= vcpu
->arch
.cop0
;
1652 struct kvm_vcpu_arch
*arch
= &vcpu
->arch
;
1653 enum emulation_result er
= EMULATE_DONE
;
1655 if ((kvm_read_c0_guest_status(cop0
) & ST0_EXL
) == 0) {
1657 kvm_write_c0_guest_epc(cop0
, arch
->pc
);
1658 kvm_set_c0_guest_status(cop0
, ST0_EXL
);
1660 if (cause
& CAUSEF_BD
)
1661 kvm_set_c0_guest_cause(cop0
, CAUSEF_BD
);
1663 kvm_clear_c0_guest_cause(cop0
, CAUSEF_BD
);
1665 kvm_change_c0_guest_cause(cop0
, (0xff),
1666 (exccode
<< CAUSEB_EXCCODE
));
1668 /* Set PC to the exception entry point */
1669 arch
->pc
= KVM_GUEST_KSEG0
+ 0x180;
1670 kvm_write_c0_guest_badvaddr(cop0
, vcpu
->arch
.host_cp0_badvaddr
);
1672 kvm_debug("Delivering EXC %d @ pc %#lx, badVaddr: %#lx\n",
1673 exccode
, kvm_read_c0_guest_epc(cop0
),
1674 kvm_read_c0_guest_badvaddr(cop0
));
1676 printk("Trying to deliver EXC when EXL is already set\n");
1683 enum emulation_result
1684 kvm_mips_check_privilege(unsigned long cause
, uint32_t *opc
,
1685 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1687 enum emulation_result er
= EMULATE_DONE
;
1688 uint32_t exccode
= (cause
>> CAUSEB_EXCCODE
) & 0x1f;
1689 unsigned long badvaddr
= vcpu
->arch
.host_cp0_badvaddr
;
1691 int usermode
= !KVM_GUEST_KERNEL_MODE(vcpu
);
1701 case T_COP_UNUSABLE
:
1702 if (((cause
& CAUSEF_CE
) >> CAUSEB_CE
) == 0)
1703 er
= EMULATE_PRIV_FAIL
;
1710 /* We we are accessing Guest kernel space, then send an address error exception to the guest */
1711 if (badvaddr
>= (unsigned long) KVM_GUEST_KSEG0
) {
1712 printk("%s: LD MISS @ %#lx\n", __func__
,
1715 cause
|= (T_ADDR_ERR_LD
<< CAUSEB_EXCCODE
);
1716 er
= EMULATE_PRIV_FAIL
;
1721 /* We we are accessing Guest kernel space, then send an address error exception to the guest */
1722 if (badvaddr
>= (unsigned long) KVM_GUEST_KSEG0
) {
1723 printk("%s: ST MISS @ %#lx\n", __func__
,
1726 cause
|= (T_ADDR_ERR_ST
<< CAUSEB_EXCCODE
);
1727 er
= EMULATE_PRIV_FAIL
;
1732 printk("%s: address error ST @ %#lx\n", __func__
,
1734 if ((badvaddr
& PAGE_MASK
) == KVM_GUEST_COMMPAGE_ADDR
) {
1736 cause
|= (T_TLB_ST_MISS
<< CAUSEB_EXCCODE
);
1738 er
= EMULATE_PRIV_FAIL
;
1741 printk("%s: address error LD @ %#lx\n", __func__
,
1743 if ((badvaddr
& PAGE_MASK
) == KVM_GUEST_COMMPAGE_ADDR
) {
1745 cause
|= (T_TLB_LD_MISS
<< CAUSEB_EXCCODE
);
1747 er
= EMULATE_PRIV_FAIL
;
1750 er
= EMULATE_PRIV_FAIL
;
1755 if (er
== EMULATE_PRIV_FAIL
) {
1756 kvm_mips_emulate_exc(cause
, opc
, run
, vcpu
);
1761 /* User Address (UA) fault, this could happen if
1762 * (1) TLB entry not present/valid in both Guest and shadow host TLBs, in this
1763 * case we pass on the fault to the guest kernel and let it handle it.
1764 * (2) TLB entry is present in the Guest TLB but not in the shadow, in this
1765 * case we inject the TLB from the Guest TLB into the shadow host TLB
1767 enum emulation_result
1768 kvm_mips_handle_tlbmiss(unsigned long cause
, uint32_t *opc
,
1769 struct kvm_run
*run
, struct kvm_vcpu
*vcpu
)
1771 enum emulation_result er
= EMULATE_DONE
;
1772 uint32_t exccode
= (cause
>> CAUSEB_EXCCODE
) & 0x1f;
1773 unsigned long va
= vcpu
->arch
.host_cp0_badvaddr
;
1776 kvm_debug("kvm_mips_handle_tlbmiss: badvaddr: %#lx, entryhi: %#lx\n",
1777 vcpu
->arch
.host_cp0_badvaddr
, vcpu
->arch
.host_cp0_entryhi
);
1779 /* KVM would not have got the exception if this entry was valid in the shadow host TLB
1780 * Check the Guest TLB, if the entry is not there then send the guest an
1781 * exception. The guest exc handler should then inject an entry into the
1784 index
= kvm_mips_guest_tlb_lookup(vcpu
,
1786 ASID_MASK(kvm_read_c0_guest_entryhi
1787 (vcpu
->arch
.cop0
)));
1789 if (exccode
== T_TLB_LD_MISS
) {
1790 er
= kvm_mips_emulate_tlbmiss_ld(cause
, opc
, run
, vcpu
);
1791 } else if (exccode
== T_TLB_ST_MISS
) {
1792 er
= kvm_mips_emulate_tlbmiss_st(cause
, opc
, run
, vcpu
);
1794 printk("%s: invalid exc code: %d\n", __func__
, exccode
);
1798 struct kvm_mips_tlb
*tlb
= &vcpu
->arch
.guest_tlb
[index
];
1800 /* Check if the entry is valid, if not then setup a TLB invalid exception to the guest */
1801 if (!TLB_IS_VALID(*tlb
, va
)) {
1802 if (exccode
== T_TLB_LD_MISS
) {
1803 er
= kvm_mips_emulate_tlbinv_ld(cause
, opc
, run
,
1805 } else if (exccode
== T_TLB_ST_MISS
) {
1806 er
= kvm_mips_emulate_tlbinv_st(cause
, opc
, run
,
1809 printk("%s: invalid exc code: %d\n", __func__
,
1816 ("Injecting hi: %#lx, lo0: %#lx, lo1: %#lx into shadow host TLB\n",
1817 tlb
->tlb_hi
, tlb
->tlb_lo0
, tlb
->tlb_lo1
);
1819 /* OK we have a Guest TLB entry, now inject it into the shadow host TLB */
1820 kvm_mips_handle_mapped_seg_tlb_fault(vcpu
, tlb
, NULL
,