projects / deliverable / linux.git / blob
? search:


e788515f766b46cefb2a36dfc95ab6bfcec6e8e3
[deliverable/linux.git] / arch / mips / kvm / emulate.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: Instruction/Exception emulation
7 *
8 * Copyright (C) 2012 MIPS Technologies, Inc. All rights reserved.
9 * Authors: Sanjay Lal <sanjayl@kymasys.com>
10 */
11
12 #include <linux/errno.h>
13 #include <linux/err.h>
14 #include <linux/ktime.h>
15 #include <linux/kvm_host.h>
16 #include <linux/module.h>
17 #include <linux/vmalloc.h>
18 #include <linux/fs.h>
19 #include <linux/bootmem.h>
20 #include <linux/random.h>
21 #include <asm/page.h>
22 #include <asm/cacheflush.h>
23 #include <asm/cacheops.h>
24 #include <asm/cpu-info.h>
25 #include <asm/mmu_context.h>
26 #include <asm/tlbflush.h>
27 #include <asm/inst.h>
28
29 #undef CONFIG_MIPS_MT
30 #include <asm/r4kcache.h>
31 #define CONFIG_MIPS_MT
32
33 #include "interrupt.h"
34 #include "commpage.h"
35
36 #include "trace.h"
37
38 /*
39 * Compute the return address and do emulate branch simulation, if required.
40 * This function should be called only in branch delay slot active.
41 */
42 unsigned long kvm_compute_return_epc(struct kvm_vcpu *vcpu,
43 unsigned long instpc)
44 {
45 unsigned int dspcontrol;
46 union mips_instruction insn;
47 struct kvm_vcpu_arch *arch = &vcpu->arch;
48 long epc = instpc;
49 long nextpc = KVM_INVALID_INST;
50
51 if (epc & 3)
52 goto unaligned;
53
54 /* Read the instruction */
55 insn.word = kvm_get_inst((u32 *) epc, vcpu);
56
57 if (insn.word == KVM_INVALID_INST)
58 return KVM_INVALID_INST;
59
60 switch (insn.i_format.opcode) {
61 /* jr and jalr are in r_format format. */
62 case spec_op:
63 switch (insn.r_format.func) {
64 case jalr_op:
65 arch->gprs[insn.r_format.rd] = epc + 8;
66 /* Fall through */
67 case jr_op:
68 nextpc = arch->gprs[insn.r_format.rs];
69 break;
70 }
71 break;
72
73 /*
74 * This group contains:
75 * bltz_op, bgez_op, bltzl_op, bgezl_op,
76 * bltzal_op, bgezal_op, bltzall_op, bgezall_op.
77 */
78 case bcond_op:
79 switch (insn.i_format.rt) {
80 case bltz_op:
81 case bltzl_op:
82 if ((long)arch->gprs[insn.i_format.rs] < 0)
83 epc = epc + 4 + (insn.i_format.simmediate << 2);
84 else
85 epc += 8;
86 nextpc = epc;
87 break;
88
89 case bgez_op:
90 case bgezl_op:
91 if ((long)arch->gprs[insn.i_format.rs] >= 0)
92 epc = epc + 4 + (insn.i_format.simmediate << 2);
93 else
94 epc += 8;
95 nextpc = epc;
96 break;
97
98 case bltzal_op:
99 case bltzall_op:
100 arch->gprs[31] = epc + 8;
101 if ((long)arch->gprs[insn.i_format.rs] < 0)
102 epc = epc + 4 + (insn.i_format.simmediate << 2);
103 else
104 epc += 8;
105 nextpc = epc;
106 break;
107
108 case bgezal_op:
109 case bgezall_op:
110 arch->gprs[31] = epc + 8;
111 if ((long)arch->gprs[insn.i_format.rs] >= 0)
112 epc = epc + 4 + (insn.i_format.simmediate << 2);
113 else
114 epc += 8;
115 nextpc = epc;
116 break;
117 case bposge32_op:
118 if (!cpu_has_dsp)
119 goto sigill;
120
121 dspcontrol = rddsp(0x01);
122
123 if (dspcontrol >= 32)
124 epc = epc + 4 + (insn.i_format.simmediate << 2);
125 else
126 epc += 8;
127 nextpc = epc;
128 break;
129 }
130 break;
131
132 /* These are unconditional and in j_format. */
133 case jal_op:
134 arch->gprs[31] = instpc + 8;
135 case j_op:
136 epc += 4;
137 epc >>= 28;
138 epc <<= 28;
139 epc |= (insn.j_format.target << 2);
140 nextpc = epc;
141 break;
142
143 /* These are conditional and in i_format. */
144 case beq_op:
145 case beql_op:
146 if (arch->gprs[insn.i_format.rs] ==
147 arch->gprs[insn.i_format.rt])
148 epc = epc + 4 + (insn.i_format.simmediate << 2);
149 else
150 epc += 8;
151 nextpc = epc;
152 break;
153
154 case bne_op:
155 case bnel_op:
156 if (arch->gprs[insn.i_format.rs] !=
157 arch->gprs[insn.i_format.rt])
158 epc = epc + 4 + (insn.i_format.simmediate << 2);
159 else
160 epc += 8;
161 nextpc = epc;
162 break;
163
164 case blez_op: /* POP06 */
165 #ifndef CONFIG_CPU_MIPSR6
166 case blezl_op: /* removed in R6 */
167 #endif
168 if (insn.i_format.rt != 0)
169 goto compact_branch;
170 if ((long)arch->gprs[insn.i_format.rs] <= 0)
171 epc = epc + 4 + (insn.i_format.simmediate << 2);
172 else
173 epc += 8;
174 nextpc = epc;
175 break;
176
177 case bgtz_op: /* POP07 */
178 #ifndef CONFIG_CPU_MIPSR6
179 case bgtzl_op: /* removed in R6 */
180 #endif
181 if (insn.i_format.rt != 0)
182 goto compact_branch;
183 if ((long)arch->gprs[insn.i_format.rs] > 0)
184 epc = epc + 4 + (insn.i_format.simmediate << 2);
185 else
186 epc += 8;
187 nextpc = epc;
188 break;
189
190 /* And now the FPA/cp1 branch instructions. */
191 case cop1_op:
192 kvm_err("%s: unsupported cop1_op\n", __func__);
193 break;
194
195 #ifdef CONFIG_CPU_MIPSR6
196 /* R6 added the following compact branches with forbidden slots */
197 case blezl_op: /* POP26 */
198 case bgtzl_op: /* POP27 */
199 /* only rt == 0 isn't compact branch */
200 if (insn.i_format.rt != 0)
201 goto compact_branch;
202 break;
203 case pop10_op:
204 case pop30_op:
205 /* only rs == rt == 0 is reserved, rest are compact branches */
206 if (insn.i_format.rs != 0 || insn.i_format.rt != 0)
207 goto compact_branch;
208 break;
209 case pop66_op:
210 case pop76_op:
211 /* only rs == 0 isn't compact branch */
212 if (insn.i_format.rs != 0)
213 goto compact_branch;
214 break;
215 compact_branch:
216 /*
217 * If we've hit an exception on the forbidden slot, then
218 * the branch must not have been taken.
219 */
220 epc += 8;
221 nextpc = epc;
222 break;
223 #else
224 compact_branch:
225 /* Compact branches not supported before R6 */
226 break;
227 #endif
228 }
229
230 return nextpc;
231
232 unaligned:
233 kvm_err("%s: unaligned epc\n", __func__);
234 return nextpc;
235
236 sigill:
237 kvm_err("%s: DSP branch but not DSP ASE\n", __func__);
238 return nextpc;
239 }
240
241 enum emulation_result update_pc(struct kvm_vcpu *vcpu, u32 cause)
242 {
243 unsigned long branch_pc;
244 enum emulation_result er = EMULATE_DONE;
245
246 if (cause & CAUSEF_BD) {
247 branch_pc = kvm_compute_return_epc(vcpu, vcpu->arch.pc);
248 if (branch_pc == KVM_INVALID_INST) {
249 er = EMULATE_FAIL;
250 } else {
251 vcpu->arch.pc = branch_pc;
252 kvm_debug("BD update_pc(): New PC: %#lx\n",
253 vcpu->arch.pc);
254 }
255 } else
256 vcpu->arch.pc += 4;
257
258 kvm_debug("update_pc(): New PC: %#lx\n", vcpu->arch.pc);
259
260 return er;
261 }
262
263 /**
264 * kvm_mips_count_disabled() - Find whether the CP0_Count timer is disabled.
265 * @vcpu: Virtual CPU.
266 *
267 * Returns: 1 if the CP0_Count timer is disabled by either the guest
268 * CP0_Cause.DC bit or the count_ctl.DC bit.
269 * 0 otherwise (in which case CP0_Count timer is running).
270 */
271 static inline int kvm_mips_count_disabled(struct kvm_vcpu *vcpu)
272 {
273 struct mips_coproc *cop0 = vcpu->arch.cop0;
274
275 return (vcpu->arch.count_ctl & KVM_REG_MIPS_COUNT_CTL_DC) ||
276 (kvm_read_c0_guest_cause(cop0) & CAUSEF_DC);
277 }
278
279 /**
280 * kvm_mips_ktime_to_count() - Scale ktime_t to a 32-bit count.
281 *
282 * Caches the dynamic nanosecond bias in vcpu->arch.count_dyn_bias.
283 *
284 * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
285 */
286 static u32 kvm_mips_ktime_to_count(struct kvm_vcpu *vcpu, ktime_t now)
287 {
288 s64 now_ns, periods;
289 u64 delta;
290
291 now_ns = ktime_to_ns(now);
292 delta = now_ns + vcpu->arch.count_dyn_bias;
293
294 if (delta >= vcpu->arch.count_period) {
295 /* If delta is out of safe range the bias needs adjusting */
296 periods = div64_s64(now_ns, vcpu->arch.count_period);
297 vcpu->arch.count_dyn_bias = -periods * vcpu->arch.count_period;
298 /* Recalculate delta with new bias */
299 delta = now_ns + vcpu->arch.count_dyn_bias;
300 }
301
302 /*
303 * We've ensured that:
304 * delta < count_period
305 *
306 * Therefore the intermediate delta*count_hz will never overflow since
307 * at the boundary condition:
308 * delta = count_period
309 * delta = NSEC_PER_SEC * 2^32 / count_hz
310 * delta * count_hz = NSEC_PER_SEC * 2^32
311 */
312 return div_u64(delta * vcpu->arch.count_hz, NSEC_PER_SEC);
313 }
314
315 /**
316 * kvm_mips_count_time() - Get effective current time.
317 * @vcpu: Virtual CPU.
318 *
319 * Get effective monotonic ktime. This is usually a straightforward ktime_get(),
320 * except when the master disable bit is set in count_ctl, in which case it is
321 * count_resume, i.e. the time that the count was disabled.
322 *
323 * Returns: Effective monotonic ktime for CP0_Count.
324 */
325 static inline ktime_t kvm_mips_count_time(struct kvm_vcpu *vcpu)
326 {
327 if (unlikely(vcpu->arch.count_ctl & KVM_REG_MIPS_COUNT_CTL_DC))
328 return vcpu->arch.count_resume;
329
330 return ktime_get();
331 }
332
333 /**
334 * kvm_mips_read_count_running() - Read the current count value as if running.
335 * @vcpu: Virtual CPU.
336 * @now: Kernel time to read CP0_Count at.
337 *
338 * Returns the current guest CP0_Count register at time @now and handles if the
339 * timer interrupt is pending and hasn't been handled yet.
340 *
341 * Returns: The current value of the guest CP0_Count register.
342 */
343 static u32 kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now)
344 {
345 struct mips_coproc *cop0 = vcpu->arch.cop0;
346 ktime_t expires, threshold;
347 u32 count, compare;
348 int running;
349
350 /* Calculate the biased and scaled guest CP0_Count */
351 count = vcpu->arch.count_bias + kvm_mips_ktime_to_count(vcpu, now);
352 compare = kvm_read_c0_guest_compare(cop0);
353
354 /*
355 * Find whether CP0_Count has reached the closest timer interrupt. If
356 * not, we shouldn't inject it.
357 */
358 if ((s32)(count - compare) < 0)
359 return count;
360
361 /*
362 * The CP0_Count we're going to return has already reached the closest
363 * timer interrupt. Quickly check if it really is a new interrupt by
364 * looking at whether the interval until the hrtimer expiry time is
365 * less than 1/4 of the timer period.
366 */
367 expires = hrtimer_get_expires(&vcpu->arch.comparecount_timer);
368 threshold = ktime_add_ns(now, vcpu->arch.count_period / 4);
369 if (ktime_before(expires, threshold)) {
370 /*
371 * Cancel it while we handle it so there's no chance of
372 * interference with the timeout handler.
373 */
374 running = hrtimer_cancel(&vcpu->arch.comparecount_timer);
375
376 /* Nothing should be waiting on the timeout */
377 kvm_mips_callbacks->queue_timer_int(vcpu);
378
379 /*
380 * Restart the timer if it was running based on the expiry time
381 * we read, so that we don't push it back 2 periods.
382 */
383 if (running) {
384 expires = ktime_add_ns(expires,
385 vcpu->arch.count_period);
386 hrtimer_start(&vcpu->arch.comparecount_timer, expires,
387 HRTIMER_MODE_ABS);
388 }
389 }
390
391 return count;
392 }
393
394 /**
395 * kvm_mips_read_count() - Read the current count value.
396 * @vcpu: Virtual CPU.
397 *
398 * Read the current guest CP0_Count value, taking into account whether the timer
399 * is stopped.
400 *
401 * Returns: The current guest CP0_Count value.
402 */
403 u32 kvm_mips_read_count(struct kvm_vcpu *vcpu)
404 {
405 struct mips_coproc *cop0 = vcpu->arch.cop0;
406
407 /* If count disabled just read static copy of count */
408 if (kvm_mips_count_disabled(vcpu))
409 return kvm_read_c0_guest_count(cop0);
410
411 return kvm_mips_read_count_running(vcpu, ktime_get());
412 }
413
414 /**
415 * kvm_mips_freeze_hrtimer() - Safely stop the hrtimer.
416 * @vcpu: Virtual CPU.
417 * @count: Output pointer for CP0_Count value at point of freeze.
418 *
419 * Freeze the hrtimer safely and return both the ktime and the CP0_Count value
420 * at the point it was frozen. It is guaranteed that any pending interrupts at
421 * the point it was frozen are handled, and none after that point.
422 *
423 * This is useful where the time/CP0_Count is needed in the calculation of the
424 * new parameters.
425 *
426 * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
427 *
428 * Returns: The ktime at the point of freeze.
429 */
430 static ktime_t kvm_mips_freeze_hrtimer(struct kvm_vcpu *vcpu, u32 *count)
431 {
432 ktime_t now;
433
434 /* stop hrtimer before finding time */
435 hrtimer_cancel(&vcpu->arch.comparecount_timer);
436 now = ktime_get();
437
438 /* find count at this point and handle pending hrtimer */
439 *count = kvm_mips_read_count_running(vcpu, now);
440
441 return now;
442 }
443
444 /**
445 * kvm_mips_resume_hrtimer() - Resume hrtimer, updating expiry.
446 * @vcpu: Virtual CPU.
447 * @now: ktime at point of resume.
448 * @count: CP0_Count at point of resume.
449 *
450 * Resumes the timer and updates the timer expiry based on @now and @count.
451 * This can be used in conjunction with kvm_mips_freeze_timer() when timer
452 * parameters need to be changed.
453 *
454 * It is guaranteed that a timer interrupt immediately after resume will be
455 * handled, but not if CP_Compare is exactly at @count. That case is already
456 * handled by kvm_mips_freeze_timer().
457 *
458 * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
459 */
460 static void kvm_mips_resume_hrtimer(struct kvm_vcpu *vcpu,
461 ktime_t now, u32 count)
462 {
463 struct mips_coproc *cop0 = vcpu->arch.cop0;
464 u32 compare;
465 u64 delta;
466 ktime_t expire;
467
468 /* Calculate timeout (wrap 0 to 2^32) */
469 compare = kvm_read_c0_guest_compare(cop0);
470 delta = (u64)(u32)(compare - count - 1) + 1;
471 delta = div_u64(delta * NSEC_PER_SEC, vcpu->arch.count_hz);
472 expire = ktime_add_ns(now, delta);
473
474 /* Update hrtimer to use new timeout */
475 hrtimer_cancel(&vcpu->arch.comparecount_timer);
476 hrtimer_start(&vcpu->arch.comparecount_timer, expire, HRTIMER_MODE_ABS);
477 }
478
479 /**
480 * kvm_mips_write_count() - Modify the count and update timer.
481 * @vcpu: Virtual CPU.
482 * @count: Guest CP0_Count value to set.
483 *
484 * Sets the CP0_Count value and updates the timer accordingly.
485 */
486 void kvm_mips_write_count(struct kvm_vcpu *vcpu, u32 count)
487 {
488 struct mips_coproc *cop0 = vcpu->arch.cop0;
489 ktime_t now;
490
491 /* Calculate bias */
492 now = kvm_mips_count_time(vcpu);
493 vcpu->arch.count_bias = count - kvm_mips_ktime_to_count(vcpu, now);
494
495 if (kvm_mips_count_disabled(vcpu))
496 /* The timer's disabled, adjust the static count */
497 kvm_write_c0_guest_count(cop0, count);
498 else
499 /* Update timeout */
500 kvm_mips_resume_hrtimer(vcpu, now, count);
501 }
502
503 /**
504 * kvm_mips_init_count() - Initialise timer.
505 * @vcpu: Virtual CPU.
506 *
507 * Initialise the timer to a sensible frequency, namely 100MHz, zero it, and set
508 * it going if it's enabled.
509 */
510 void kvm_mips_init_count(struct kvm_vcpu *vcpu)
511 {
512 /* 100 MHz */
513 vcpu->arch.count_hz = 100*1000*1000;
514 vcpu->arch.count_period = div_u64((u64)NSEC_PER_SEC << 32,
515 vcpu->arch.count_hz);
516 vcpu->arch.count_dyn_bias = 0;
517
518 /* Starting at 0 */
519 kvm_mips_write_count(vcpu, 0);
520 }
521
522 /**
523 * kvm_mips_set_count_hz() - Update the frequency of the timer.
524 * @vcpu: Virtual CPU.
525 * @count_hz: Frequency of CP0_Count timer in Hz.
526 *
527 * Change the frequency of the CP0_Count timer. This is done atomically so that
528 * CP0_Count is continuous and no timer interrupt is lost.
529 *
530 * Returns: -EINVAL if @count_hz is out of range.
531 * 0 on success.
532 */
533 int kvm_mips_set_count_hz(struct kvm_vcpu *vcpu, s64 count_hz)
534 {
535 struct mips_coproc *cop0 = vcpu->arch.cop0;
536 int dc;
537 ktime_t now;
538 u32 count;
539
540 /* ensure the frequency is in a sensible range... */
541 if (count_hz <= 0 || count_hz > NSEC_PER_SEC)
542 return -EINVAL;
543 /* ... and has actually changed */
544 if (vcpu->arch.count_hz == count_hz)
545 return 0;
546
547 /* Safely freeze timer so we can keep it continuous */
548 dc = kvm_mips_count_disabled(vcpu);
549 if (dc) {
550 now = kvm_mips_count_time(vcpu);
551 count = kvm_read_c0_guest_count(cop0);
552 } else {
553 now = kvm_mips_freeze_hrtimer(vcpu, &count);
554 }
555
556 /* Update the frequency */
557 vcpu->arch.count_hz = count_hz;
558 vcpu->arch.count_period = div_u64((u64)NSEC_PER_SEC << 32, count_hz);
559 vcpu->arch.count_dyn_bias = 0;
560
561 /* Calculate adjusted bias so dynamic count is unchanged */
562 vcpu->arch.count_bias = count - kvm_mips_ktime_to_count(vcpu, now);
563
564 /* Update and resume hrtimer */
565 if (!dc)
566 kvm_mips_resume_hrtimer(vcpu, now, count);
567 return 0;
568 }
569
570 /**
571 * kvm_mips_write_compare() - Modify compare and update timer.
572 * @vcpu: Virtual CPU.
573 * @compare: New CP0_Compare value.
574 * @ack: Whether to acknowledge timer interrupt.
575 *
576 * Update CP0_Compare to a new value and update the timeout.
577 * If @ack, atomically acknowledge any pending timer interrupt, otherwise ensure
578 * any pending timer interrupt is preserved.
579 */
580 void kvm_mips_write_compare(struct kvm_vcpu *vcpu, u32 compare, bool ack)
581 {
582 struct mips_coproc *cop0 = vcpu->arch.cop0;
583 int dc;
584 u32 old_compare = kvm_read_c0_guest_compare(cop0);
585 ktime_t now;
586 u32 count;
587
588 /* if unchanged, must just be an ack */
589 if (old_compare == compare) {
590 if (!ack)
591 return;
592 kvm_mips_callbacks->dequeue_timer_int(vcpu);
593 kvm_write_c0_guest_compare(cop0, compare);
594 return;
595 }
596
597 /* freeze_hrtimer() takes care of timer interrupts <= count */
598 dc = kvm_mips_count_disabled(vcpu);
599 if (!dc)
600 now = kvm_mips_freeze_hrtimer(vcpu, &count);
601
602 if (ack)
603 kvm_mips_callbacks->dequeue_timer_int(vcpu);
604
605 kvm_write_c0_guest_compare(cop0, compare);
606
607 /* resume_hrtimer() takes care of timer interrupts > count */
608 if (!dc)
609 kvm_mips_resume_hrtimer(vcpu, now, count);
610 }
611
612 /**
613 * kvm_mips_count_disable() - Disable count.
614 * @vcpu: Virtual CPU.
615 *
616 * Disable the CP0_Count timer. A timer interrupt on or before the final stop
617 * time will be handled but not after.
618 *
619 * Assumes CP0_Count was previously enabled but now Guest.CP0_Cause.DC or
620 * count_ctl.DC has been set (count disabled).
621 *
622 * Returns: The time that the timer was stopped.
623 */
624 static ktime_t kvm_mips_count_disable(struct kvm_vcpu *vcpu)
625 {
626 struct mips_coproc *cop0 = vcpu->arch.cop0;
627 u32 count;
628 ktime_t now;
629
630 /* Stop hrtimer */
631 hrtimer_cancel(&vcpu->arch.comparecount_timer);
632
633 /* Set the static count from the dynamic count, handling pending TI */
634 now = ktime_get();
635 count = kvm_mips_read_count_running(vcpu, now);
636 kvm_write_c0_guest_count(cop0, count);
637
638 return now;
639 }
640
641 /**
642 * kvm_mips_count_disable_cause() - Disable count using CP0_Cause.DC.
643 * @vcpu: Virtual CPU.
644 *
645 * Disable the CP0_Count timer and set CP0_Cause.DC. A timer interrupt on or
646 * before the final stop time will be handled if the timer isn't disabled by
647 * count_ctl.DC, but not after.
648 *
649 * Assumes CP0_Cause.DC is clear (count enabled).
650 */
651 void kvm_mips_count_disable_cause(struct kvm_vcpu *vcpu)
652 {
653 struct mips_coproc *cop0 = vcpu->arch.cop0;
654
655 kvm_set_c0_guest_cause(cop0, CAUSEF_DC);
656 if (!(vcpu->arch.count_ctl & KVM_REG_MIPS_COUNT_CTL_DC))
657 kvm_mips_count_disable(vcpu);
658 }
659
660 /**
661 * kvm_mips_count_enable_cause() - Enable count using CP0_Cause.DC.
662 * @vcpu: Virtual CPU.
663 *
664 * Enable the CP0_Count timer and clear CP0_Cause.DC. A timer interrupt after
665 * the start time will be handled if the timer isn't disabled by count_ctl.DC,
666 * potentially before even returning, so the caller should be careful with
667 * ordering of CP0_Cause modifications so as not to lose it.
668 *
669 * Assumes CP0_Cause.DC is set (count disabled).
670 */
671 void kvm_mips_count_enable_cause(struct kvm_vcpu *vcpu)
672 {
673 struct mips_coproc *cop0 = vcpu->arch.cop0;
674 u32 count;
675
676 kvm_clear_c0_guest_cause(cop0, CAUSEF_DC);
677
678 /*
679 * Set the dynamic count to match the static count.
680 * This starts the hrtimer if count_ctl.DC allows it.
681 * Otherwise it conveniently updates the biases.
682 */
683 count = kvm_read_c0_guest_count(cop0);
684 kvm_mips_write_count(vcpu, count);
685 }
686
687 /**
688 * kvm_mips_set_count_ctl() - Update the count control KVM register.
689 * @vcpu: Virtual CPU.
690 * @count_ctl: Count control register new value.
691 *
692 * Set the count control KVM register. The timer is updated accordingly.
693 *
694 * Returns: -EINVAL if reserved bits are set.
695 * 0 on success.
696 */
697 int kvm_mips_set_count_ctl(struct kvm_vcpu *vcpu, s64 count_ctl)
698 {
699 struct mips_coproc *cop0 = vcpu->arch.cop0;
700 s64 changed = count_ctl ^ vcpu->arch.count_ctl;
701 s64 delta;
702 ktime_t expire, now;
703 u32 count, compare;
704
705 /* Only allow defined bits to be changed */
706 if (changed & ~(s64)(KVM_REG_MIPS_COUNT_CTL_DC))
707 return -EINVAL;
708
709 /* Apply new value */
710 vcpu->arch.count_ctl = count_ctl;
711
712 /* Master CP0_Count disable */
713 if (changed & KVM_REG_MIPS_COUNT_CTL_DC) {
714 /* Is CP0_Cause.DC already disabling CP0_Count? */
715 if (kvm_read_c0_guest_cause(cop0) & CAUSEF_DC) {
716 if (count_ctl & KVM_REG_MIPS_COUNT_CTL_DC)
717 /* Just record the current time */
718 vcpu->arch.count_resume = ktime_get();
719 } else if (count_ctl & KVM_REG_MIPS_COUNT_CTL_DC) {
720 /* disable timer and record current time */
721 vcpu->arch.count_resume = kvm_mips_count_disable(vcpu);
722 } else {
723 /*
724 * Calculate timeout relative to static count at resume
725 * time (wrap 0 to 2^32).
726 */
727 count = kvm_read_c0_guest_count(cop0);
728 compare = kvm_read_c0_guest_compare(cop0);
729 delta = (u64)(u32)(compare - count - 1) + 1;
730 delta = div_u64(delta * NSEC_PER_SEC,
731 vcpu->arch.count_hz);
732 expire = ktime_add_ns(vcpu->arch.count_resume, delta);
733
734 /* Handle pending interrupt */
735 now = ktime_get();
736 if (ktime_compare(now, expire) >= 0)
737 /* Nothing should be waiting on the timeout */
738 kvm_mips_callbacks->queue_timer_int(vcpu);
739
740 /* Resume hrtimer without changing bias */
741 count = kvm_mips_read_count_running(vcpu, now);
742 kvm_mips_resume_hrtimer(vcpu, now, count);
743 }
744 }
745
746 return 0;
747 }
748
749 /**
750 * kvm_mips_set_count_resume() - Update the count resume KVM register.
751 * @vcpu: Virtual CPU.
752 * @count_resume: Count resume register new value.
753 *
754 * Set the count resume KVM register.
755 *
756 * Returns: -EINVAL if out of valid range (0..now).
757 * 0 on success.
758 */
759 int kvm_mips_set_count_resume(struct kvm_vcpu *vcpu, s64 count_resume)
760 {
761 /*
762 * It doesn't make sense for the resume time to be in the future, as it
763 * would be possible for the next interrupt to be more than a full
764 * period in the future.
765 */
766 if (count_resume < 0 || count_resume > ktime_to_ns(ktime_get()))
767 return -EINVAL;
768
769 vcpu->arch.count_resume = ns_to_ktime(count_resume);
770 return 0;
771 }
772
773 /**
774 * kvm_mips_count_timeout() - Push timer forward on timeout.
775 * @vcpu: Virtual CPU.
776 *
777 * Handle an hrtimer event by push the hrtimer forward a period.
778 *
779 * Returns: The hrtimer_restart value to return to the hrtimer subsystem.
780 */
781 enum hrtimer_restart kvm_mips_count_timeout(struct kvm_vcpu *vcpu)
782 {
783 /* Add the Count period to the current expiry time */
784 hrtimer_add_expires_ns(&vcpu->arch.comparecount_timer,
785 vcpu->arch.count_period);
786 return HRTIMER_RESTART;
787 }
788
789 enum emulation_result kvm_mips_emul_eret(struct kvm_vcpu *vcpu)
790 {
791 struct mips_coproc *cop0 = vcpu->arch.cop0;
792 enum emulation_result er = EMULATE_DONE;
793
794 if (kvm_read_c0_guest_status(cop0) & ST0_EXL) {
795 kvm_debug("[%#lx] ERET to %#lx\n", vcpu->arch.pc,
796 kvm_read_c0_guest_epc(cop0));
797 kvm_clear_c0_guest_status(cop0, ST0_EXL);
798 vcpu->arch.pc = kvm_read_c0_guest_epc(cop0);
799
800 } else if (kvm_read_c0_guest_status(cop0) & ST0_ERL) {
801 kvm_clear_c0_guest_status(cop0, ST0_ERL);
802 vcpu->arch.pc = kvm_read_c0_guest_errorepc(cop0);
803 } else {
804 kvm_err("[%#lx] ERET when MIPS_SR_EXL|MIPS_SR_ERL == 0\n",
805 vcpu->arch.pc);
806 er = EMULATE_FAIL;
807 }
808
809 return er;
810 }
811
812 enum emulation_result kvm_mips_emul_wait(struct kvm_vcpu *vcpu)
813 {
814 kvm_debug("[%#lx] !!!WAIT!!! (%#lx)\n", vcpu->arch.pc,
815 vcpu->arch.pending_exceptions);
816
817 ++vcpu->stat.wait_exits;
818 trace_kvm_exit(vcpu, KVM_TRACE_EXIT_WAIT);
819 if (!vcpu->arch.pending_exceptions) {
820 vcpu->arch.wait = 1;
821 kvm_vcpu_block(vcpu);
822
823 /*
824 * We we are runnable, then definitely go off to user space to
825 * check if any I/O interrupts are pending.
826 */
827 if (kvm_check_request(KVM_REQ_UNHALT, vcpu)) {
828 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
829 vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
830 }
831 }
832
833 return EMULATE_DONE;
834 }
835
836 /*
837 * XXXKYMA: Linux doesn't seem to use TLBR, return EMULATE_FAIL for now so that
838 * we can catch this, if things ever change
839 */
840 enum emulation_result kvm_mips_emul_tlbr(struct kvm_vcpu *vcpu)
841 {
842 struct mips_coproc *cop0 = vcpu->arch.cop0;
843 unsigned long pc = vcpu->arch.pc;
844
845 kvm_err("[%#lx] COP0_TLBR [%ld]\n", pc, kvm_read_c0_guest_index(cop0));
846 return EMULATE_FAIL;
847 }
848
849 /* Write Guest TLB Entry @ Index */
850 enum emulation_result kvm_mips_emul_tlbwi(struct kvm_vcpu *vcpu)
851 {
852 struct mips_coproc *cop0 = vcpu->arch.cop0;
853 int index = kvm_read_c0_guest_index(cop0);
854 struct kvm_mips_tlb *tlb = NULL;
855 unsigned long pc = vcpu->arch.pc;
856
857 if (index < 0 || index >= KVM_MIPS_GUEST_TLB_SIZE) {
858 kvm_debug("%s: illegal index: %d\n", __func__, index);
859 kvm_debug("[%#lx] COP0_TLBWI [%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx, mask: %#lx)\n",
860 pc, index, kvm_read_c0_guest_entryhi(cop0),
861 kvm_read_c0_guest_entrylo0(cop0),
862 kvm_read_c0_guest_entrylo1(cop0),
863 kvm_read_c0_guest_pagemask(cop0));
864 index = (index & ~0x80000000) % KVM_MIPS_GUEST_TLB_SIZE;
865 }
866
867 tlb = &vcpu->arch.guest_tlb[index];
868 /*
869 * Probe the shadow host TLB for the entry being overwritten, if one
870 * matches, invalidate it
871 */
872 kvm_mips_host_tlb_inv(vcpu, tlb->tlb_hi);
873
874 tlb->tlb_mask = kvm_read_c0_guest_pagemask(cop0);
875 tlb->tlb_hi = kvm_read_c0_guest_entryhi(cop0);
876 tlb->tlb_lo[0] = kvm_read_c0_guest_entrylo0(cop0);
877 tlb->tlb_lo[1] = kvm_read_c0_guest_entrylo1(cop0);
878
879 kvm_debug("[%#lx] COP0_TLBWI [%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx, mask: %#lx)\n",
880 pc, index, kvm_read_c0_guest_entryhi(cop0),
881 kvm_read_c0_guest_entrylo0(cop0),
882 kvm_read_c0_guest_entrylo1(cop0),
883 kvm_read_c0_guest_pagemask(cop0));
884
885 return EMULATE_DONE;
886 }
887
888 /* Write Guest TLB Entry @ Random Index */
889 enum emulation_result kvm_mips_emul_tlbwr(struct kvm_vcpu *vcpu)
890 {
891 struct mips_coproc *cop0 = vcpu->arch.cop0;
892 struct kvm_mips_tlb *tlb = NULL;
893 unsigned long pc = vcpu->arch.pc;
894 int index;
895
896 get_random_bytes(&index, sizeof(index));
897 index &= (KVM_MIPS_GUEST_TLB_SIZE - 1);
898
899 tlb = &vcpu->arch.guest_tlb[index];
900
901 /*
902 * Probe the shadow host TLB for the entry being overwritten, if one
903 * matches, invalidate it
904 */
905 kvm_mips_host_tlb_inv(vcpu, tlb->tlb_hi);
906
907 tlb->tlb_mask = kvm_read_c0_guest_pagemask(cop0);
908 tlb->tlb_hi = kvm_read_c0_guest_entryhi(cop0);
909 tlb->tlb_lo[0] = kvm_read_c0_guest_entrylo0(cop0);
910 tlb->tlb_lo[1] = kvm_read_c0_guest_entrylo1(cop0);
911
912 kvm_debug("[%#lx] COP0_TLBWR[%d] (entryhi: %#lx, entrylo0: %#lx entrylo1: %#lx)\n",
913 pc, index, kvm_read_c0_guest_entryhi(cop0),
914 kvm_read_c0_guest_entrylo0(cop0),
915 kvm_read_c0_guest_entrylo1(cop0));
916
917 return EMULATE_DONE;
918 }
919
920 enum emulation_result kvm_mips_emul_tlbp(struct kvm_vcpu *vcpu)
921 {
922 struct mips_coproc *cop0 = vcpu->arch.cop0;
923 long entryhi = kvm_read_c0_guest_entryhi(cop0);
924 unsigned long pc = vcpu->arch.pc;
925 int index = -1;
926
927 index = kvm_mips_guest_tlb_lookup(vcpu, entryhi);
928
929 kvm_write_c0_guest_index(cop0, index);
930
931 kvm_debug("[%#lx] COP0_TLBP (entryhi: %#lx), index: %d\n", pc, entryhi,
932 index);
933
934 return EMULATE_DONE;
935 }
936
937 /**
938 * kvm_mips_config1_wrmask() - Find mask of writable bits in guest Config1
939 * @vcpu: Virtual CPU.
940 *
941 * Finds the mask of bits which are writable in the guest's Config1 CP0
942 * register, by userland (currently read-only to the guest).
943 */
944 unsigned int kvm_mips_config1_wrmask(struct kvm_vcpu *vcpu)
945 {
946 unsigned int mask = 0;
947
948 /* Permit FPU to be present if FPU is supported */
949 if (kvm_mips_guest_can_have_fpu(&vcpu->arch))
950 mask |= MIPS_CONF1_FP;
951
952 return mask;
953 }
954
955 /**
956 * kvm_mips_config3_wrmask() - Find mask of writable bits in guest Config3
957 * @vcpu: Virtual CPU.
958 *
959 * Finds the mask of bits which are writable in the guest's Config3 CP0
960 * register, by userland (currently read-only to the guest).
961 */
962 unsigned int kvm_mips_config3_wrmask(struct kvm_vcpu *vcpu)
963 {
964 /* Config4 and ULRI are optional */
965 unsigned int mask = MIPS_CONF_M | MIPS_CONF3_ULRI;
966
967 /* Permit MSA to be present if MSA is supported */
968 if (kvm_mips_guest_can_have_msa(&vcpu->arch))
969 mask |= MIPS_CONF3_MSA;
970
971 return mask;
972 }
973
974 /**
975 * kvm_mips_config4_wrmask() - Find mask of writable bits in guest Config4
976 * @vcpu: Virtual CPU.
977 *
978 * Finds the mask of bits which are writable in the guest's Config4 CP0
979 * register, by userland (currently read-only to the guest).
980 */
981 unsigned int kvm_mips_config4_wrmask(struct kvm_vcpu *vcpu)
982 {
983 /* Config5 is optional */
984 unsigned int mask = MIPS_CONF_M;
985
986 /* KScrExist */
987 mask |= (unsigned int)vcpu->arch.kscratch_enabled << 16;
988
989 return mask;
990 }
991
992 /**
993 * kvm_mips_config5_wrmask() - Find mask of writable bits in guest Config5
994 * @vcpu: Virtual CPU.
995 *
996 * Finds the mask of bits which are writable in the guest's Config5 CP0
997 * register, by the guest itself.
998 */
999 unsigned int kvm_mips_config5_wrmask(struct kvm_vcpu *vcpu)
1000 {
1001 unsigned int mask = 0;
1002
1003 /* Permit MSAEn changes if MSA supported and enabled */
1004 if (kvm_mips_guest_has_msa(&vcpu->arch))
1005 mask |= MIPS_CONF5_MSAEN;
1006
1007 /*
1008 * Permit guest FPU mode changes if FPU is enabled and the relevant
1009 * feature exists according to FIR register.
1010 */
1011 if (kvm_mips_guest_has_fpu(&vcpu->arch)) {
1012 if (cpu_has_fre)
1013 mask |= MIPS_CONF5_FRE;
1014 /* We don't support UFR or UFE */
1015 }
1016
1017 return mask;
1018 }
1019
1020 enum emulation_result kvm_mips_emulate_CP0(union mips_instruction inst,
1021 u32 *opc, u32 cause,
1022 struct kvm_run *run,
1023 struct kvm_vcpu *vcpu)
1024 {
1025 struct mips_coproc *cop0 = vcpu->arch.cop0;
1026 enum emulation_result er = EMULATE_DONE;
1027 u32 rt, rd, sel;
1028 unsigned long curr_pc;
1029
1030 /*
1031 * Update PC and hold onto current PC in case there is
1032 * an error and we want to rollback the PC
1033 */
1034 curr_pc = vcpu->arch.pc;
1035 er = update_pc(vcpu, cause);
1036 if (er == EMULATE_FAIL)
1037 return er;
1038
1039 if (inst.co_format.co) {
1040 switch (inst.co_format.func) {
1041 case tlbr_op: /* Read indexed TLB entry */
1042 er = kvm_mips_emul_tlbr(vcpu);
1043 break;
1044 case tlbwi_op: /* Write indexed */
1045 er = kvm_mips_emul_tlbwi(vcpu);
1046 break;
1047 case tlbwr_op: /* Write random */
1048 er = kvm_mips_emul_tlbwr(vcpu);
1049 break;
1050 case tlbp_op: /* TLB Probe */
1051 er = kvm_mips_emul_tlbp(vcpu);
1052 break;
1053 case rfe_op:
1054 kvm_err("!!!COP0_RFE!!!\n");
1055 break;
1056 case eret_op:
1057 er = kvm_mips_emul_eret(vcpu);
1058 goto dont_update_pc;
1059 case wait_op:
1060 er = kvm_mips_emul_wait(vcpu);
1061 break;
1062 }
1063 } else {
1064 rt = inst.c0r_format.rt;
1065 rd = inst.c0r_format.rd;
1066 sel = inst.c0r_format.sel;
1067
1068 switch (inst.c0r_format.rs) {
1069 case mfc_op:
1070 #ifdef CONFIG_KVM_MIPS_DEBUG_COP0_COUNTERS
1071 cop0->stat[rd][sel]++;
1072 #endif
1073 /* Get reg */
1074 if ((rd == MIPS_CP0_COUNT) && (sel == 0)) {
1075 vcpu->arch.gprs[rt] =
1076 (s32)kvm_mips_read_count(vcpu);
1077 } else if ((rd == MIPS_CP0_ERRCTL) && (sel == 0)) {
1078 vcpu->arch.gprs[rt] = 0x0;
1079 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1080 kvm_mips_trans_mfc0(inst, opc, vcpu);
1081 #endif
1082 } else {
1083 vcpu->arch.gprs[rt] = (s32)cop0->reg[rd][sel];
1084
1085 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1086 kvm_mips_trans_mfc0(inst, opc, vcpu);
1087 #endif
1088 }
1089
1090 trace_kvm_hwr(vcpu, KVM_TRACE_MFC0,
1091 KVM_TRACE_COP0(rd, sel),
1092 vcpu->arch.gprs[rt]);
1093 break;
1094
1095 case dmfc_op:
1096 vcpu->arch.gprs[rt] = cop0->reg[rd][sel];
1097
1098 trace_kvm_hwr(vcpu, KVM_TRACE_DMFC0,
1099 KVM_TRACE_COP0(rd, sel),
1100 vcpu->arch.gprs[rt]);
1101 break;
1102
1103 case mtc_op:
1104 #ifdef CONFIG_KVM_MIPS_DEBUG_COP0_COUNTERS
1105 cop0->stat[rd][sel]++;
1106 #endif
1107 trace_kvm_hwr(vcpu, KVM_TRACE_MTC0,
1108 KVM_TRACE_COP0(rd, sel),
1109 vcpu->arch.gprs[rt]);
1110
1111 if ((rd == MIPS_CP0_TLB_INDEX)
1112 && (vcpu->arch.gprs[rt] >=
1113 KVM_MIPS_GUEST_TLB_SIZE)) {
1114 kvm_err("Invalid TLB Index: %ld",
1115 vcpu->arch.gprs[rt]);
1116 er = EMULATE_FAIL;
1117 break;
1118 }
1119 #define C0_EBASE_CORE_MASK 0xff
1120 if ((rd == MIPS_CP0_PRID) && (sel == 1)) {
1121 /* Preserve CORE number */
1122 kvm_change_c0_guest_ebase(cop0,
1123 ~(C0_EBASE_CORE_MASK),
1124 vcpu->arch.gprs[rt]);
1125 kvm_err("MTCz, cop0->reg[EBASE]: %#lx\n",
1126 kvm_read_c0_guest_ebase(cop0));
1127 } else if (rd == MIPS_CP0_TLB_HI && sel == 0) {
1128 u32 nasid =
1129 vcpu->arch.gprs[rt] & KVM_ENTRYHI_ASID;
1130 if ((KSEGX(vcpu->arch.gprs[rt]) != CKSEG0) &&
1131 ((kvm_read_c0_guest_entryhi(cop0) &
1132 KVM_ENTRYHI_ASID) != nasid)) {
1133 trace_kvm_asid_change(vcpu,
1134 kvm_read_c0_guest_entryhi(cop0)
1135 & KVM_ENTRYHI_ASID,
1136 nasid);
1137
1138 /* Blow away the shadow host TLBs */
1139 kvm_mips_flush_host_tlb(1);
1140 }
1141 kvm_write_c0_guest_entryhi(cop0,
1142 vcpu->arch.gprs[rt]);
1143 }
1144 /* Are we writing to COUNT */
1145 else if ((rd == MIPS_CP0_COUNT) && (sel == 0)) {
1146 kvm_mips_write_count(vcpu, vcpu->arch.gprs[rt]);
1147 goto done;
1148 } else if ((rd == MIPS_CP0_COMPARE) && (sel == 0)) {
1149 /* If we are writing to COMPARE */
1150 /* Clear pending timer interrupt, if any */
1151 kvm_mips_write_compare(vcpu,
1152 vcpu->arch.gprs[rt],
1153 true);
1154 } else if ((rd == MIPS_CP0_STATUS) && (sel == 0)) {
1155 unsigned int old_val, val, change;
1156
1157 old_val = kvm_read_c0_guest_status(cop0);
1158 val = vcpu->arch.gprs[rt];
1159 change = val ^ old_val;
1160
1161 /* Make sure that the NMI bit is never set */
1162 val &= ~ST0_NMI;
1163
1164 /*
1165 * Don't allow CU1 or FR to be set unless FPU
1166 * capability enabled and exists in guest
1167 * configuration.
1168 */
1169 if (!kvm_mips_guest_has_fpu(&vcpu->arch))
1170 val &= ~(ST0_CU1 | ST0_FR);
1171
1172 /*
1173 * Also don't allow FR to be set if host doesn't
1174 * support it.
1175 */
1176 if (!(current_cpu_data.fpu_id & MIPS_FPIR_F64))
1177 val &= ~ST0_FR;
1178
1179
1180 /* Handle changes in FPU mode */
1181 preempt_disable();
1182
1183 /*
1184 * FPU and Vector register state is made
1185 * UNPREDICTABLE by a change of FR, so don't
1186 * even bother saving it.
1187 */
1188 if (change & ST0_FR)
1189 kvm_drop_fpu(vcpu);
1190
1191 /*
1192 * If MSA state is already live, it is undefined
1193 * how it interacts with FR=0 FPU state, and we
1194 * don't want to hit reserved instruction
1195 * exceptions trying to save the MSA state later
1196 * when CU=1 && FR=1, so play it safe and save
1197 * it first.
1198 */
1199 if (change & ST0_CU1 && !(val & ST0_FR) &&
1200 vcpu->arch.aux_inuse & KVM_MIPS_AUX_MSA)
1201 kvm_lose_fpu(vcpu);
1202
1203 /*
1204 * Propagate CU1 (FPU enable) changes
1205 * immediately if the FPU context is already
1206 * loaded. When disabling we leave the context
1207 * loaded so it can be quickly enabled again in
1208 * the near future.
1209 */
1210 if (change & ST0_CU1 &&
1211 vcpu->arch.aux_inuse & KVM_MIPS_AUX_FPU)
1212 change_c0_status(ST0_CU1, val);
1213
1214 preempt_enable();
1215
1216 kvm_write_c0_guest_status(cop0, val);
1217
1218 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1219 /*
1220 * If FPU present, we need CU1/FR bits to take
1221 * effect fairly soon.
1222 */
1223 if (!kvm_mips_guest_has_fpu(&vcpu->arch))
1224 kvm_mips_trans_mtc0(inst, opc, vcpu);
1225 #endif
1226 } else if ((rd == MIPS_CP0_CONFIG) && (sel == 5)) {
1227 unsigned int old_val, val, change, wrmask;
1228
1229 old_val = kvm_read_c0_guest_config5(cop0);
1230 val = vcpu->arch.gprs[rt];
1231
1232 /* Only a few bits are writable in Config5 */
1233 wrmask = kvm_mips_config5_wrmask(vcpu);
1234 change = (val ^ old_val) & wrmask;
1235 val = old_val ^ change;
1236
1237
1238 /* Handle changes in FPU/MSA modes */
1239 preempt_disable();
1240
1241 /*
1242 * Propagate FRE changes immediately if the FPU
1243 * context is already loaded.
1244 */
1245 if (change & MIPS_CONF5_FRE &&
1246 vcpu->arch.aux_inuse & KVM_MIPS_AUX_FPU)
1247 change_c0_config5(MIPS_CONF5_FRE, val);
1248
1249 /*
1250 * Propagate MSAEn changes immediately if the
1251 * MSA context is already loaded. When disabling
1252 * we leave the context loaded so it can be
1253 * quickly enabled again in the near future.
1254 */
1255 if (change & MIPS_CONF5_MSAEN &&
1256 vcpu->arch.aux_inuse & KVM_MIPS_AUX_MSA)
1257 change_c0_config5(MIPS_CONF5_MSAEN,
1258 val);
1259
1260 preempt_enable();
1261
1262 kvm_write_c0_guest_config5(cop0, val);
1263 } else if ((rd == MIPS_CP0_CAUSE) && (sel == 0)) {
1264 u32 old_cause, new_cause;
1265
1266 old_cause = kvm_read_c0_guest_cause(cop0);
1267 new_cause = vcpu->arch.gprs[rt];
1268 /* Update R/W bits */
1269 kvm_change_c0_guest_cause(cop0, 0x08800300,
1270 new_cause);
1271 /* DC bit enabling/disabling timer? */
1272 if ((old_cause ^ new_cause) & CAUSEF_DC) {
1273 if (new_cause & CAUSEF_DC)
1274 kvm_mips_count_disable_cause(vcpu);
1275 else
1276 kvm_mips_count_enable_cause(vcpu);
1277 }
1278 } else if ((rd == MIPS_CP0_HWRENA) && (sel == 0)) {
1279 u32 mask = MIPS_HWRENA_CPUNUM |
1280 MIPS_HWRENA_SYNCISTEP |
1281 MIPS_HWRENA_CC |
1282 MIPS_HWRENA_CCRES;
1283
1284 if (kvm_read_c0_guest_config3(cop0) &
1285 MIPS_CONF3_ULRI)
1286 mask |= MIPS_HWRENA_ULR;
1287 cop0->reg[rd][sel] = vcpu->arch.gprs[rt] & mask;
1288 } else {
1289 cop0->reg[rd][sel] = vcpu->arch.gprs[rt];
1290 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1291 kvm_mips_trans_mtc0(inst, opc, vcpu);
1292 #endif
1293 }
1294 break;
1295
1296 case dmtc_op:
1297 kvm_err("!!!!!!![%#lx]dmtc_op: rt: %d, rd: %d, sel: %d!!!!!!\n",
1298 vcpu->arch.pc, rt, rd, sel);
1299 trace_kvm_hwr(vcpu, KVM_TRACE_DMTC0,
1300 KVM_TRACE_COP0(rd, sel),
1301 vcpu->arch.gprs[rt]);
1302 er = EMULATE_FAIL;
1303 break;
1304
1305 case mfmc0_op:
1306 #ifdef KVM_MIPS_DEBUG_COP0_COUNTERS
1307 cop0->stat[MIPS_CP0_STATUS][0]++;
1308 #endif
1309 if (rt != 0)
1310 vcpu->arch.gprs[rt] =
1311 kvm_read_c0_guest_status(cop0);
1312 /* EI */
1313 if (inst.mfmc0_format.sc) {
1314 kvm_debug("[%#lx] mfmc0_op: EI\n",
1315 vcpu->arch.pc);
1316 kvm_set_c0_guest_status(cop0, ST0_IE);
1317 } else {
1318 kvm_debug("[%#lx] mfmc0_op: DI\n",
1319 vcpu->arch.pc);
1320 kvm_clear_c0_guest_status(cop0, ST0_IE);
1321 }
1322
1323 break;
1324
1325 case wrpgpr_op:
1326 {
1327 u32 css = cop0->reg[MIPS_CP0_STATUS][2] & 0xf;
1328 u32 pss =
1329 (cop0->reg[MIPS_CP0_STATUS][2] >> 6) & 0xf;
1330 /*
1331 * We don't support any shadow register sets, so
1332 * SRSCtl[PSS] == SRSCtl[CSS] = 0
1333 */
1334 if (css || pss) {
1335 er = EMULATE_FAIL;
1336 break;
1337 }
1338 kvm_debug("WRPGPR[%d][%d] = %#lx\n", pss, rd,
1339 vcpu->arch.gprs[rt]);
1340 vcpu->arch.gprs[rd] = vcpu->arch.gprs[rt];
1341 }
1342 break;
1343 default:
1344 kvm_err("[%#lx]MachEmulateCP0: unsupported COP0, copz: 0x%x\n",
1345 vcpu->arch.pc, inst.c0r_format.rs);
1346 er = EMULATE_FAIL;
1347 break;
1348 }
1349 }
1350
1351 done:
1352 /* Rollback PC only if emulation was unsuccessful */
1353 if (er == EMULATE_FAIL)
1354 vcpu->arch.pc = curr_pc;
1355
1356 dont_update_pc:
1357 /*
1358 * This is for special instructions whose emulation
1359 * updates the PC, so do not overwrite the PC under
1360 * any circumstances
1361 */
1362
1363 return er;
1364 }
1365
1366 enum emulation_result kvm_mips_emulate_store(union mips_instruction inst,
1367 u32 cause,
1368 struct kvm_run *run,
1369 struct kvm_vcpu *vcpu)
1370 {
1371 enum emulation_result er = EMULATE_DO_MMIO;
1372 u32 rt;
1373 u32 bytes;
1374 void *data = run->mmio.data;
1375 unsigned long curr_pc;
1376
1377 /*
1378 * Update PC and hold onto current PC in case there is
1379 * an error and we want to rollback the PC
1380 */
1381 curr_pc = vcpu->arch.pc;
1382 er = update_pc(vcpu, cause);
1383 if (er == EMULATE_FAIL)
1384 return er;
1385
1386 rt = inst.i_format.rt;
1387
1388 switch (inst.i_format.opcode) {
1389 case sb_op:
1390 bytes = 1;
1391 if (bytes > sizeof(run->mmio.data)) {
1392 kvm_err("%s: bad MMIO length: %d\n", __func__,
1393 run->mmio.len);
1394 }
1395 run->mmio.phys_addr =
1396 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1397 host_cp0_badvaddr);
1398 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1399 er = EMULATE_FAIL;
1400 break;
1401 }
1402 run->mmio.len = bytes;
1403 run->mmio.is_write = 1;
1404 vcpu->mmio_needed = 1;
1405 vcpu->mmio_is_write = 1;
1406 *(u8 *) data = vcpu->arch.gprs[rt];
1407 kvm_debug("OP_SB: eaddr: %#lx, gpr: %#lx, data: %#x\n",
1408 vcpu->arch.host_cp0_badvaddr, vcpu->arch.gprs[rt],
1409 *(u8 *) data);
1410
1411 break;
1412
1413 case sw_op:
1414 bytes = 4;
1415 if (bytes > sizeof(run->mmio.data)) {
1416 kvm_err("%s: bad MMIO length: %d\n", __func__,
1417 run->mmio.len);
1418 }
1419 run->mmio.phys_addr =
1420 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1421 host_cp0_badvaddr);
1422 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1423 er = EMULATE_FAIL;
1424 break;
1425 }
1426
1427 run->mmio.len = bytes;
1428 run->mmio.is_write = 1;
1429 vcpu->mmio_needed = 1;
1430 vcpu->mmio_is_write = 1;
1431 *(u32 *) data = vcpu->arch.gprs[rt];
1432
1433 kvm_debug("[%#lx] OP_SW: eaddr: %#lx, gpr: %#lx, data: %#x\n",
1434 vcpu->arch.pc, vcpu->arch.host_cp0_badvaddr,
1435 vcpu->arch.gprs[rt], *(u32 *) data);
1436 break;
1437
1438 case sh_op:
1439 bytes = 2;
1440 if (bytes > sizeof(run->mmio.data)) {
1441 kvm_err("%s: bad MMIO length: %d\n", __func__,
1442 run->mmio.len);
1443 }
1444 run->mmio.phys_addr =
1445 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1446 host_cp0_badvaddr);
1447 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1448 er = EMULATE_FAIL;
1449 break;
1450 }
1451
1452 run->mmio.len = bytes;
1453 run->mmio.is_write = 1;
1454 vcpu->mmio_needed = 1;
1455 vcpu->mmio_is_write = 1;
1456 *(u16 *) data = vcpu->arch.gprs[rt];
1457
1458 kvm_debug("[%#lx] OP_SH: eaddr: %#lx, gpr: %#lx, data: %#x\n",
1459 vcpu->arch.pc, vcpu->arch.host_cp0_badvaddr,
1460 vcpu->arch.gprs[rt], *(u32 *) data);
1461 break;
1462
1463 default:
1464 kvm_err("Store not yet supported (inst=0x%08x)\n",
1465 inst.word);
1466 er = EMULATE_FAIL;
1467 break;
1468 }
1469
1470 /* Rollback PC if emulation was unsuccessful */
1471 if (er == EMULATE_FAIL)
1472 vcpu->arch.pc = curr_pc;
1473
1474 return er;
1475 }
1476
1477 enum emulation_result kvm_mips_emulate_load(union mips_instruction inst,
1478 u32 cause, struct kvm_run *run,
1479 struct kvm_vcpu *vcpu)
1480 {
1481 enum emulation_result er = EMULATE_DO_MMIO;
1482 u32 op, rt;
1483 u32 bytes;
1484
1485 rt = inst.i_format.rt;
1486 op = inst.i_format.opcode;
1487
1488 vcpu->arch.pending_load_cause = cause;
1489 vcpu->arch.io_gpr = rt;
1490
1491 switch (op) {
1492 case lw_op:
1493 bytes = 4;
1494 if (bytes > sizeof(run->mmio.data)) {
1495 kvm_err("%s: bad MMIO length: %d\n", __func__,
1496 run->mmio.len);
1497 er = EMULATE_FAIL;
1498 break;
1499 }
1500 run->mmio.phys_addr =
1501 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1502 host_cp0_badvaddr);
1503 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1504 er = EMULATE_FAIL;
1505 break;
1506 }
1507
1508 run->mmio.len = bytes;
1509 run->mmio.is_write = 0;
1510 vcpu->mmio_needed = 1;
1511 vcpu->mmio_is_write = 0;
1512 break;
1513
1514 case lh_op:
1515 case lhu_op:
1516 bytes = 2;
1517 if (bytes > sizeof(run->mmio.data)) {
1518 kvm_err("%s: bad MMIO length: %d\n", __func__,
1519 run->mmio.len);
1520 er = EMULATE_FAIL;
1521 break;
1522 }
1523 run->mmio.phys_addr =
1524 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1525 host_cp0_badvaddr);
1526 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1527 er = EMULATE_FAIL;
1528 break;
1529 }
1530
1531 run->mmio.len = bytes;
1532 run->mmio.is_write = 0;
1533 vcpu->mmio_needed = 1;
1534 vcpu->mmio_is_write = 0;
1535
1536 if (op == lh_op)
1537 vcpu->mmio_needed = 2;
1538 else
1539 vcpu->mmio_needed = 1;
1540
1541 break;
1542
1543 case lbu_op:
1544 case lb_op:
1545 bytes = 1;
1546 if (bytes > sizeof(run->mmio.data)) {
1547 kvm_err("%s: bad MMIO length: %d\n", __func__,
1548 run->mmio.len);
1549 er = EMULATE_FAIL;
1550 break;
1551 }
1552 run->mmio.phys_addr =
1553 kvm_mips_callbacks->gva_to_gpa(vcpu->arch.
1554 host_cp0_badvaddr);
1555 if (run->mmio.phys_addr == KVM_INVALID_ADDR) {
1556 er = EMULATE_FAIL;
1557 break;
1558 }
1559
1560 run->mmio.len = bytes;
1561 run->mmio.is_write = 0;
1562 vcpu->mmio_is_write = 0;
1563
1564 if (op == lb_op)
1565 vcpu->mmio_needed = 2;
1566 else
1567 vcpu->mmio_needed = 1;
1568
1569 break;
1570
1571 default:
1572 kvm_err("Load not yet supported (inst=0x%08x)\n",
1573 inst.word);
1574 er = EMULATE_FAIL;
1575 break;
1576 }
1577
1578 return er;
1579 }
1580
1581 enum emulation_result kvm_mips_emulate_cache(union mips_instruction inst,
1582 u32 *opc, u32 cause,
1583 struct kvm_run *run,
1584 struct kvm_vcpu *vcpu)
1585 {
1586 struct mips_coproc *cop0 = vcpu->arch.cop0;
1587 enum emulation_result er = EMULATE_DONE;
1588 u32 cache, op_inst, op, base;
1589 s16 offset;
1590 struct kvm_vcpu_arch *arch = &vcpu->arch;
1591 unsigned long va;
1592 unsigned long curr_pc;
1593
1594 /*
1595 * Update PC and hold onto current PC in case there is
1596 * an error and we want to rollback the PC
1597 */
1598 curr_pc = vcpu->arch.pc;
1599 er = update_pc(vcpu, cause);
1600 if (er == EMULATE_FAIL)
1601 return er;
1602
1603 base = inst.i_format.rs;
1604 op_inst = inst.i_format.rt;
1605 if (cpu_has_mips_r6)
1606 offset = inst.spec3_format.simmediate;
1607 else
1608 offset = inst.i_format.simmediate;
1609 cache = op_inst & CacheOp_Cache;
1610 op = op_inst & CacheOp_Op;
1611
1612 va = arch->gprs[base] + offset;
1613
1614 kvm_debug("CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1615 cache, op, base, arch->gprs[base], offset);
1616
1617 /*
1618 * Treat INDEX_INV as a nop, basically issued by Linux on startup to
1619 * invalidate the caches entirely by stepping through all the
1620 * ways/indexes
1621 */
1622 if (op == Index_Writeback_Inv) {
1623 kvm_debug("@ %#lx/%#lx CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1624 vcpu->arch.pc, vcpu->arch.gprs[31], cache, op, base,
1625 arch->gprs[base], offset);
1626
1627 if (cache == Cache_D)
1628 r4k_blast_dcache();
1629 else if (cache == Cache_I)
1630 r4k_blast_icache();
1631 else {
1632 kvm_err("%s: unsupported CACHE INDEX operation\n",
1633 __func__);
1634 return EMULATE_FAIL;
1635 }
1636
1637 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1638 kvm_mips_trans_cache_index(inst, opc, vcpu);
1639 #endif
1640 goto done;
1641 }
1642
1643 preempt_disable();
1644 if (KVM_GUEST_KSEGX(va) == KVM_GUEST_KSEG0) {
1645 if (kvm_mips_host_tlb_lookup(vcpu, va) < 0 &&
1646 kvm_mips_handle_kseg0_tlb_fault(va, vcpu)) {
1647 kvm_err("%s: handling mapped kseg0 tlb fault for %lx, vcpu: %p, ASID: %#lx\n",
1648 __func__, va, vcpu, read_c0_entryhi());
1649 er = EMULATE_FAIL;
1650 preempt_enable();
1651 goto done;
1652 }
1653 } else if ((KVM_GUEST_KSEGX(va) < KVM_GUEST_KSEG0) ||
1654 KVM_GUEST_KSEGX(va) == KVM_GUEST_KSEG23) {
1655 int index;
1656
1657 /* If an entry already exists then skip */
1658 if (kvm_mips_host_tlb_lookup(vcpu, va) >= 0)
1659 goto skip_fault;
1660
1661 /*
1662 * If address not in the guest TLB, then give the guest a fault,
1663 * the resulting handler will do the right thing
1664 */
1665 index = kvm_mips_guest_tlb_lookup(vcpu, (va & VPN2_MASK) |
1666 (kvm_read_c0_guest_entryhi
1667 (cop0) & KVM_ENTRYHI_ASID));
1668
1669 if (index < 0) {
1670 vcpu->arch.host_cp0_badvaddr = va;
1671 vcpu->arch.pc = curr_pc;
1672 er = kvm_mips_emulate_tlbmiss_ld(cause, NULL, run,
1673 vcpu);
1674 preempt_enable();
1675 goto dont_update_pc;
1676 } else {
1677 struct kvm_mips_tlb *tlb = &vcpu->arch.guest_tlb[index];
1678 /*
1679 * Check if the entry is valid, if not then setup a TLB
1680 * invalid exception to the guest
1681 */
1682 if (!TLB_IS_VALID(*tlb, va)) {
1683 vcpu->arch.host_cp0_badvaddr = va;
1684 vcpu->arch.pc = curr_pc;
1685 er = kvm_mips_emulate_tlbinv_ld(cause, NULL,
1686 run, vcpu);
1687 preempt_enable();
1688 goto dont_update_pc;
1689 }
1690 /*
1691 * We fault an entry from the guest tlb to the
1692 * shadow host TLB
1693 */
1694 if (kvm_mips_handle_mapped_seg_tlb_fault(vcpu, tlb)) {
1695 kvm_err("%s: handling mapped seg tlb fault for %lx, index: %u, vcpu: %p, ASID: %#lx\n",
1696 __func__, va, index, vcpu,
1697 read_c0_entryhi());
1698 er = EMULATE_FAIL;
1699 preempt_enable();
1700 goto done;
1701 }
1702 }
1703 } else {
1704 kvm_err("INVALID CACHE INDEX/ADDRESS (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1705 cache, op, base, arch->gprs[base], offset);
1706 er = EMULATE_FAIL;
1707 preempt_enable();
1708 goto done;
1709
1710 }
1711
1712 skip_fault:
1713 /* XXXKYMA: Only a subset of cache ops are supported, used by Linux */
1714 if (op_inst == Hit_Writeback_Inv_D || op_inst == Hit_Invalidate_D) {
1715 flush_dcache_line(va);
1716
1717 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1718 /*
1719 * Replace the CACHE instruction, with a SYNCI, not the same,
1720 * but avoids a trap
1721 */
1722 kvm_mips_trans_cache_va(inst, opc, vcpu);
1723 #endif
1724 } else if (op_inst == Hit_Invalidate_I) {
1725 flush_dcache_line(va);
1726 flush_icache_line(va);
1727
1728 #ifdef CONFIG_KVM_MIPS_DYN_TRANS
1729 /* Replace the CACHE instruction, with a SYNCI */
1730 kvm_mips_trans_cache_va(inst, opc, vcpu);
1731 #endif
1732 } else {
1733 kvm_err("NO-OP CACHE (cache: %#x, op: %#x, base[%d]: %#lx, offset: %#x\n",
1734 cache, op, base, arch->gprs[base], offset);
1735 er = EMULATE_FAIL;
1736 }
1737
1738 preempt_enable();
1739 done:
1740 /* Rollback PC only if emulation was unsuccessful */
1741 if (er == EMULATE_FAIL)
1742 vcpu->arch.pc = curr_pc;
1743
1744 dont_update_pc:
1745 /*
1746 * This is for exceptions whose emulation updates the PC, so do not
1747 * overwrite the PC under any circumstances
1748 */
1749
1750 return er;
1751 }
1752
1753 enum emulation_result kvm_mips_emulate_inst(u32 cause, u32 *opc,
1754 struct kvm_run *run,
1755 struct kvm_vcpu *vcpu)
1756 {
1757 union mips_instruction inst;
1758 enum emulation_result er = EMULATE_DONE;
1759
1760 /* Fetch the instruction. */
1761 if (cause & CAUSEF_BD)
1762 opc += 1;
1763
1764 inst.word = kvm_get_inst(opc, vcpu);
1765
1766 switch (inst.r_format.opcode) {
1767 case cop0_op:
1768 er = kvm_mips_emulate_CP0(inst, opc, cause, run, vcpu);
1769 break;
1770 case sb_op:
1771 case sh_op:
1772 case sw_op:
1773 er = kvm_mips_emulate_store(inst, cause, run, vcpu);
1774 break;
1775 case lb_op:
1776 case lbu_op:
1777 case lhu_op:
1778 case lh_op:
1779 case lw_op:
1780 er = kvm_mips_emulate_load(inst, cause, run, vcpu);
1781 break;
1782
1783 #ifndef CONFIG_CPU_MIPSR6
1784 case cache_op:
1785 ++vcpu->stat.cache_exits;
1786 trace_kvm_exit(vcpu, KVM_TRACE_EXIT_CACHE);
1787 er = kvm_mips_emulate_cache(inst, opc, cause, run, vcpu);
1788 break;
1789 #else
1790 case spec3_op:
1791 switch (inst.spec3_format.func) {
1792 case cache6_op:
1793 ++vcpu->stat.cache_exits;
1794 trace_kvm_exit(vcpu, KVM_TRACE_EXIT_CACHE);
1795 er = kvm_mips_emulate_cache(inst, opc, cause, run,
1796 vcpu);
1797 break;
1798 default:
1799 goto unknown;
1800 };
1801 break;
1802 unknown:
1803 #endif
1804
1805 default:
1806 kvm_err("Instruction emulation not supported (%p/%#x)\n", opc,
1807 inst.word);
1808 kvm_arch_vcpu_dump_regs(vcpu);
1809 er = EMULATE_FAIL;
1810 break;
1811 }
1812
1813 return er;
1814 }
1815
1816 enum emulation_result kvm_mips_emulate_syscall(u32 cause,
1817 u32 *opc,
1818 struct kvm_run *run,
1819 struct kvm_vcpu *vcpu)
1820 {
1821 struct mips_coproc *cop0 = vcpu->arch.cop0;
1822 struct kvm_vcpu_arch *arch = &vcpu->arch;
1823 enum emulation_result er = EMULATE_DONE;
1824
1825 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
1826 /* save old pc */
1827 kvm_write_c0_guest_epc(cop0, arch->pc);
1828 kvm_set_c0_guest_status(cop0, ST0_EXL);
1829
1830 if (cause & CAUSEF_BD)
1831 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
1832 else
1833 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
1834
1835 kvm_debug("Delivering SYSCALL @ pc %#lx\n", arch->pc);
1836
1837 kvm_change_c0_guest_cause(cop0, (0xff),
1838 (EXCCODE_SYS << CAUSEB_EXCCODE));
1839
1840 /* Set PC to the exception entry point */
1841 arch->pc = KVM_GUEST_KSEG0 + 0x180;
1842
1843 } else {
1844 kvm_err("Trying to deliver SYSCALL when EXL is already set\n");
1845 er = EMULATE_FAIL;
1846 }
1847
1848 return er;
1849 }
1850
1851 enum emulation_result kvm_mips_emulate_tlbmiss_ld(u32 cause,
1852 u32 *opc,
1853 struct kvm_run *run,
1854 struct kvm_vcpu *vcpu)
1855 {
1856 struct mips_coproc *cop0 = vcpu->arch.cop0;
1857 struct kvm_vcpu_arch *arch = &vcpu->arch;
1858 unsigned long entryhi = (vcpu->arch. host_cp0_badvaddr & VPN2_MASK) |
1859 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
1860
1861 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
1862 /* save old pc */
1863 kvm_write_c0_guest_epc(cop0, arch->pc);
1864 kvm_set_c0_guest_status(cop0, ST0_EXL);
1865
1866 if (cause & CAUSEF_BD)
1867 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
1868 else
1869 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
1870
1871 kvm_debug("[EXL == 0] delivering TLB MISS @ pc %#lx\n",
1872 arch->pc);
1873
1874 /* set pc to the exception entry point */
1875 arch->pc = KVM_GUEST_KSEG0 + 0x0;
1876
1877 } else {
1878 kvm_debug("[EXL == 1] delivering TLB MISS @ pc %#lx\n",
1879 arch->pc);
1880
1881 arch->pc = KVM_GUEST_KSEG0 + 0x180;
1882 }
1883
1884 kvm_change_c0_guest_cause(cop0, (0xff),
1885 (EXCCODE_TLBL << CAUSEB_EXCCODE));
1886
1887 /* setup badvaddr, context and entryhi registers for the guest */
1888 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
1889 /* XXXKYMA: is the context register used by linux??? */
1890 kvm_write_c0_guest_entryhi(cop0, entryhi);
1891 /* Blow away the shadow host TLBs */
1892 kvm_mips_flush_host_tlb(1);
1893
1894 return EMULATE_DONE;
1895 }
1896
1897 enum emulation_result kvm_mips_emulate_tlbinv_ld(u32 cause,
1898 u32 *opc,
1899 struct kvm_run *run,
1900 struct kvm_vcpu *vcpu)
1901 {
1902 struct mips_coproc *cop0 = vcpu->arch.cop0;
1903 struct kvm_vcpu_arch *arch = &vcpu->arch;
1904 unsigned long entryhi =
1905 (vcpu->arch.host_cp0_badvaddr & VPN2_MASK) |
1906 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
1907
1908 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
1909 /* save old pc */
1910 kvm_write_c0_guest_epc(cop0, arch->pc);
1911 kvm_set_c0_guest_status(cop0, ST0_EXL);
1912
1913 if (cause & CAUSEF_BD)
1914 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
1915 else
1916 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
1917
1918 kvm_debug("[EXL == 0] delivering TLB INV @ pc %#lx\n",
1919 arch->pc);
1920
1921 /* set pc to the exception entry point */
1922 arch->pc = KVM_GUEST_KSEG0 + 0x180;
1923
1924 } else {
1925 kvm_debug("[EXL == 1] delivering TLB MISS @ pc %#lx\n",
1926 arch->pc);
1927 arch->pc = KVM_GUEST_KSEG0 + 0x180;
1928 }
1929
1930 kvm_change_c0_guest_cause(cop0, (0xff),
1931 (EXCCODE_TLBL << CAUSEB_EXCCODE));
1932
1933 /* setup badvaddr, context and entryhi registers for the guest */
1934 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
1935 /* XXXKYMA: is the context register used by linux??? */
1936 kvm_write_c0_guest_entryhi(cop0, entryhi);
1937 /* Blow away the shadow host TLBs */
1938 kvm_mips_flush_host_tlb(1);
1939
1940 return EMULATE_DONE;
1941 }
1942
1943 enum emulation_result kvm_mips_emulate_tlbmiss_st(u32 cause,
1944 u32 *opc,
1945 struct kvm_run *run,
1946 struct kvm_vcpu *vcpu)
1947 {
1948 struct mips_coproc *cop0 = vcpu->arch.cop0;
1949 struct kvm_vcpu_arch *arch = &vcpu->arch;
1950 unsigned long entryhi = (vcpu->arch.host_cp0_badvaddr & VPN2_MASK) |
1951 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
1952
1953 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
1954 /* save old pc */
1955 kvm_write_c0_guest_epc(cop0, arch->pc);
1956 kvm_set_c0_guest_status(cop0, ST0_EXL);
1957
1958 if (cause & CAUSEF_BD)
1959 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
1960 else
1961 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
1962
1963 kvm_debug("[EXL == 0] Delivering TLB MISS @ pc %#lx\n",
1964 arch->pc);
1965
1966 /* Set PC to the exception entry point */
1967 arch->pc = KVM_GUEST_KSEG0 + 0x0;
1968 } else {
1969 kvm_debug("[EXL == 1] Delivering TLB MISS @ pc %#lx\n",
1970 arch->pc);
1971 arch->pc = KVM_GUEST_KSEG0 + 0x180;
1972 }
1973
1974 kvm_change_c0_guest_cause(cop0, (0xff),
1975 (EXCCODE_TLBS << CAUSEB_EXCCODE));
1976
1977 /* setup badvaddr, context and entryhi registers for the guest */
1978 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
1979 /* XXXKYMA: is the context register used by linux??? */
1980 kvm_write_c0_guest_entryhi(cop0, entryhi);
1981 /* Blow away the shadow host TLBs */
1982 kvm_mips_flush_host_tlb(1);
1983
1984 return EMULATE_DONE;
1985 }
1986
1987 enum emulation_result kvm_mips_emulate_tlbinv_st(u32 cause,
1988 u32 *opc,
1989 struct kvm_run *run,
1990 struct kvm_vcpu *vcpu)
1991 {
1992 struct mips_coproc *cop0 = vcpu->arch.cop0;
1993 struct kvm_vcpu_arch *arch = &vcpu->arch;
1994 unsigned long entryhi = (vcpu->arch.host_cp0_badvaddr & VPN2_MASK) |
1995 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
1996
1997 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
1998 /* save old pc */
1999 kvm_write_c0_guest_epc(cop0, arch->pc);
2000 kvm_set_c0_guest_status(cop0, ST0_EXL);
2001
2002 if (cause & CAUSEF_BD)
2003 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2004 else
2005 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2006
2007 kvm_debug("[EXL == 0] Delivering TLB MISS @ pc %#lx\n",
2008 arch->pc);
2009
2010 /* Set PC to the exception entry point */
2011 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2012 } else {
2013 kvm_debug("[EXL == 1] Delivering TLB MISS @ pc %#lx\n",
2014 arch->pc);
2015 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2016 }
2017
2018 kvm_change_c0_guest_cause(cop0, (0xff),
2019 (EXCCODE_TLBS << CAUSEB_EXCCODE));
2020
2021 /* setup badvaddr, context and entryhi registers for the guest */
2022 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
2023 /* XXXKYMA: is the context register used by linux??? */
2024 kvm_write_c0_guest_entryhi(cop0, entryhi);
2025 /* Blow away the shadow host TLBs */
2026 kvm_mips_flush_host_tlb(1);
2027
2028 return EMULATE_DONE;
2029 }
2030
2031 /* TLBMOD: store into address matching TLB with Dirty bit off */
2032 enum emulation_result kvm_mips_handle_tlbmod(u32 cause, u32 *opc,
2033 struct kvm_run *run,
2034 struct kvm_vcpu *vcpu)
2035 {
2036 enum emulation_result er = EMULATE_DONE;
2037 #ifdef DEBUG
2038 struct mips_coproc *cop0 = vcpu->arch.cop0;
2039 unsigned long entryhi = (vcpu->arch.host_cp0_badvaddr & VPN2_MASK) |
2040 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
2041 int index;
2042
2043 /* If address not in the guest TLB, then we are in trouble */
2044 index = kvm_mips_guest_tlb_lookup(vcpu, entryhi);
2045 if (index < 0) {
2046 /* XXXKYMA Invalidate and retry */
2047 kvm_mips_host_tlb_inv(vcpu, vcpu->arch.host_cp0_badvaddr);
2048 kvm_err("%s: host got TLBMOD for %#lx but entry not present in Guest TLB\n",
2049 __func__, entryhi);
2050 kvm_mips_dump_guest_tlbs(vcpu);
2051 kvm_mips_dump_host_tlbs();
2052 return EMULATE_FAIL;
2053 }
2054 #endif
2055
2056 er = kvm_mips_emulate_tlbmod(cause, opc, run, vcpu);
2057 return er;
2058 }
2059
2060 enum emulation_result kvm_mips_emulate_tlbmod(u32 cause,
2061 u32 *opc,
2062 struct kvm_run *run,
2063 struct kvm_vcpu *vcpu)
2064 {
2065 struct mips_coproc *cop0 = vcpu->arch.cop0;
2066 unsigned long entryhi = (vcpu->arch.host_cp0_badvaddr & VPN2_MASK) |
2067 (kvm_read_c0_guest_entryhi(cop0) & KVM_ENTRYHI_ASID);
2068 struct kvm_vcpu_arch *arch = &vcpu->arch;
2069
2070 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2071 /* save old pc */
2072 kvm_write_c0_guest_epc(cop0, arch->pc);
2073 kvm_set_c0_guest_status(cop0, ST0_EXL);
2074
2075 if (cause & CAUSEF_BD)
2076 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2077 else
2078 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2079
2080 kvm_debug("[EXL == 0] Delivering TLB MOD @ pc %#lx\n",
2081 arch->pc);
2082
2083 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2084 } else {
2085 kvm_debug("[EXL == 1] Delivering TLB MOD @ pc %#lx\n",
2086 arch->pc);
2087 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2088 }
2089
2090 kvm_change_c0_guest_cause(cop0, (0xff),
2091 (EXCCODE_MOD << CAUSEB_EXCCODE));
2092
2093 /* setup badvaddr, context and entryhi registers for the guest */
2094 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
2095 /* XXXKYMA: is the context register used by linux??? */
2096 kvm_write_c0_guest_entryhi(cop0, entryhi);
2097 /* Blow away the shadow host TLBs */
2098 kvm_mips_flush_host_tlb(1);
2099
2100 return EMULATE_DONE;
2101 }
2102
2103 enum emulation_result kvm_mips_emulate_fpu_exc(u32 cause,
2104 u32 *opc,
2105 struct kvm_run *run,
2106 struct kvm_vcpu *vcpu)
2107 {
2108 struct mips_coproc *cop0 = vcpu->arch.cop0;
2109 struct kvm_vcpu_arch *arch = &vcpu->arch;
2110
2111 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2112 /* save old pc */
2113 kvm_write_c0_guest_epc(cop0, arch->pc);
2114 kvm_set_c0_guest_status(cop0, ST0_EXL);
2115
2116 if (cause & CAUSEF_BD)
2117 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2118 else
2119 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2120
2121 }
2122
2123 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2124
2125 kvm_change_c0_guest_cause(cop0, (0xff),
2126 (EXCCODE_CPU << CAUSEB_EXCCODE));
2127 kvm_change_c0_guest_cause(cop0, (CAUSEF_CE), (0x1 << CAUSEB_CE));
2128
2129 return EMULATE_DONE;
2130 }
2131
2132 enum emulation_result kvm_mips_emulate_ri_exc(u32 cause,
2133 u32 *opc,
2134 struct kvm_run *run,
2135 struct kvm_vcpu *vcpu)
2136 {
2137 struct mips_coproc *cop0 = vcpu->arch.cop0;
2138 struct kvm_vcpu_arch *arch = &vcpu->arch;
2139 enum emulation_result er = EMULATE_DONE;
2140
2141 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2142 /* save old pc */
2143 kvm_write_c0_guest_epc(cop0, arch->pc);
2144 kvm_set_c0_guest_status(cop0, ST0_EXL);
2145
2146 if (cause & CAUSEF_BD)
2147 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2148 else
2149 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2150
2151 kvm_debug("Delivering RI @ pc %#lx\n", arch->pc);
2152
2153 kvm_change_c0_guest_cause(cop0, (0xff),
2154 (EXCCODE_RI << CAUSEB_EXCCODE));
2155
2156 /* Set PC to the exception entry point */
2157 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2158
2159 } else {
2160 kvm_err("Trying to deliver RI when EXL is already set\n");
2161 er = EMULATE_FAIL;
2162 }
2163
2164 return er;
2165 }
2166
2167 enum emulation_result kvm_mips_emulate_bp_exc(u32 cause,
2168 u32 *opc,
2169 struct kvm_run *run,
2170 struct kvm_vcpu *vcpu)
2171 {
2172 struct mips_coproc *cop0 = vcpu->arch.cop0;
2173 struct kvm_vcpu_arch *arch = &vcpu->arch;
2174 enum emulation_result er = EMULATE_DONE;
2175
2176 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2177 /* save old pc */
2178 kvm_write_c0_guest_epc(cop0, arch->pc);
2179 kvm_set_c0_guest_status(cop0, ST0_EXL);
2180
2181 if (cause & CAUSEF_BD)
2182 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2183 else
2184 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2185
2186 kvm_debug("Delivering BP @ pc %#lx\n", arch->pc);
2187
2188 kvm_change_c0_guest_cause(cop0, (0xff),
2189 (EXCCODE_BP << CAUSEB_EXCCODE));
2190
2191 /* Set PC to the exception entry point */
2192 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2193
2194 } else {
2195 kvm_err("Trying to deliver BP when EXL is already set\n");
2196 er = EMULATE_FAIL;
2197 }
2198
2199 return er;
2200 }
2201
2202 enum emulation_result kvm_mips_emulate_trap_exc(u32 cause,
2203 u32 *opc,
2204 struct kvm_run *run,
2205 struct kvm_vcpu *vcpu)
2206 {
2207 struct mips_coproc *cop0 = vcpu->arch.cop0;
2208 struct kvm_vcpu_arch *arch = &vcpu->arch;
2209 enum emulation_result er = EMULATE_DONE;
2210
2211 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2212 /* save old pc */
2213 kvm_write_c0_guest_epc(cop0, arch->pc);
2214 kvm_set_c0_guest_status(cop0, ST0_EXL);
2215
2216 if (cause & CAUSEF_BD)
2217 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2218 else
2219 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2220
2221 kvm_debug("Delivering TRAP @ pc %#lx\n", arch->pc);
2222
2223 kvm_change_c0_guest_cause(cop0, (0xff),
2224 (EXCCODE_TR << CAUSEB_EXCCODE));
2225
2226 /* Set PC to the exception entry point */
2227 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2228
2229 } else {
2230 kvm_err("Trying to deliver TRAP when EXL is already set\n");
2231 er = EMULATE_FAIL;
2232 }
2233
2234 return er;
2235 }
2236
2237 enum emulation_result kvm_mips_emulate_msafpe_exc(u32 cause,
2238 u32 *opc,
2239 struct kvm_run *run,
2240 struct kvm_vcpu *vcpu)
2241 {
2242 struct mips_coproc *cop0 = vcpu->arch.cop0;
2243 struct kvm_vcpu_arch *arch = &vcpu->arch;
2244 enum emulation_result er = EMULATE_DONE;
2245
2246 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2247 /* save old pc */
2248 kvm_write_c0_guest_epc(cop0, arch->pc);
2249 kvm_set_c0_guest_status(cop0, ST0_EXL);
2250
2251 if (cause & CAUSEF_BD)
2252 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2253 else
2254 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2255
2256 kvm_debug("Delivering MSAFPE @ pc %#lx\n", arch->pc);
2257
2258 kvm_change_c0_guest_cause(cop0, (0xff),
2259 (EXCCODE_MSAFPE << CAUSEB_EXCCODE));
2260
2261 /* Set PC to the exception entry point */
2262 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2263
2264 } else {
2265 kvm_err("Trying to deliver MSAFPE when EXL is already set\n");
2266 er = EMULATE_FAIL;
2267 }
2268
2269 return er;
2270 }
2271
2272 enum emulation_result kvm_mips_emulate_fpe_exc(u32 cause,
2273 u32 *opc,
2274 struct kvm_run *run,
2275 struct kvm_vcpu *vcpu)
2276 {
2277 struct mips_coproc *cop0 = vcpu->arch.cop0;
2278 struct kvm_vcpu_arch *arch = &vcpu->arch;
2279 enum emulation_result er = EMULATE_DONE;
2280
2281 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2282 /* save old pc */
2283 kvm_write_c0_guest_epc(cop0, arch->pc);
2284 kvm_set_c0_guest_status(cop0, ST0_EXL);
2285
2286 if (cause & CAUSEF_BD)
2287 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2288 else
2289 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2290
2291 kvm_debug("Delivering FPE @ pc %#lx\n", arch->pc);
2292
2293 kvm_change_c0_guest_cause(cop0, (0xff),
2294 (EXCCODE_FPE << CAUSEB_EXCCODE));
2295
2296 /* Set PC to the exception entry point */
2297 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2298
2299 } else {
2300 kvm_err("Trying to deliver FPE when EXL is already set\n");
2301 er = EMULATE_FAIL;
2302 }
2303
2304 return er;
2305 }
2306
2307 enum emulation_result kvm_mips_emulate_msadis_exc(u32 cause,
2308 u32 *opc,
2309 struct kvm_run *run,
2310 struct kvm_vcpu *vcpu)
2311 {
2312 struct mips_coproc *cop0 = vcpu->arch.cop0;
2313 struct kvm_vcpu_arch *arch = &vcpu->arch;
2314 enum emulation_result er = EMULATE_DONE;
2315
2316 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2317 /* save old pc */
2318 kvm_write_c0_guest_epc(cop0, arch->pc);
2319 kvm_set_c0_guest_status(cop0, ST0_EXL);
2320
2321 if (cause & CAUSEF_BD)
2322 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2323 else
2324 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2325
2326 kvm_debug("Delivering MSADIS @ pc %#lx\n", arch->pc);
2327
2328 kvm_change_c0_guest_cause(cop0, (0xff),
2329 (EXCCODE_MSADIS << CAUSEB_EXCCODE));
2330
2331 /* Set PC to the exception entry point */
2332 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2333
2334 } else {
2335 kvm_err("Trying to deliver MSADIS when EXL is already set\n");
2336 er = EMULATE_FAIL;
2337 }
2338
2339 return er;
2340 }
2341
2342 enum emulation_result kvm_mips_handle_ri(u32 cause, u32 *opc,
2343 struct kvm_run *run,
2344 struct kvm_vcpu *vcpu)
2345 {
2346 struct mips_coproc *cop0 = vcpu->arch.cop0;
2347 struct kvm_vcpu_arch *arch = &vcpu->arch;
2348 enum emulation_result er = EMULATE_DONE;
2349 unsigned long curr_pc;
2350 union mips_instruction inst;
2351
2352 /*
2353 * Update PC and hold onto current PC in case there is
2354 * an error and we want to rollback the PC
2355 */
2356 curr_pc = vcpu->arch.pc;
2357 er = update_pc(vcpu, cause);
2358 if (er == EMULATE_FAIL)
2359 return er;
2360
2361 /* Fetch the instruction. */
2362 if (cause & CAUSEF_BD)
2363 opc += 1;
2364
2365 inst.word = kvm_get_inst(opc, vcpu);
2366
2367 if (inst.word == KVM_INVALID_INST) {
2368 kvm_err("%s: Cannot get inst @ %p\n", __func__, opc);
2369 return EMULATE_FAIL;
2370 }
2371
2372 if (inst.r_format.opcode == spec3_op &&
2373 inst.r_format.func == rdhwr_op &&
2374 inst.r_format.rs == 0 &&
2375 (inst.r_format.re >> 3) == 0) {
2376 int usermode = !KVM_GUEST_KERNEL_MODE(vcpu);
2377 int rd = inst.r_format.rd;
2378 int rt = inst.r_format.rt;
2379 int sel = inst.r_format.re & 0x7;
2380
2381 /* If usermode, check RDHWR rd is allowed by guest HWREna */
2382 if (usermode && !(kvm_read_c0_guest_hwrena(cop0) & BIT(rd))) {
2383 kvm_debug("RDHWR %#x disallowed by HWREna @ %p\n",
2384 rd, opc);
2385 goto emulate_ri;
2386 }
2387 switch (rd) {
2388 case MIPS_HWR_CPUNUM: /* CPU number */
2389 arch->gprs[rt] = vcpu->vcpu_id;
2390 break;
2391 case MIPS_HWR_SYNCISTEP: /* SYNCI length */
2392 arch->gprs[rt] = min(current_cpu_data.dcache.linesz,
2393 current_cpu_data.icache.linesz);
2394 break;
2395 case MIPS_HWR_CC: /* Read count register */
2396 arch->gprs[rt] = (s32)kvm_mips_read_count(vcpu);
2397 break;
2398 case MIPS_HWR_CCRES: /* Count register resolution */
2399 switch (current_cpu_data.cputype) {
2400 case CPU_20KC:
2401 case CPU_25KF:
2402 arch->gprs[rt] = 1;
2403 break;
2404 default:
2405 arch->gprs[rt] = 2;
2406 }
2407 break;
2408 case MIPS_HWR_ULR: /* Read UserLocal register */
2409 arch->gprs[rt] = kvm_read_c0_guest_userlocal(cop0);
2410 break;
2411
2412 default:
2413 kvm_debug("RDHWR %#x not supported @ %p\n", rd, opc);
2414 goto emulate_ri;
2415 }
2416
2417 trace_kvm_hwr(vcpu, KVM_TRACE_RDHWR, KVM_TRACE_HWR(rd, sel),
2418 vcpu->arch.gprs[rt]);
2419 } else {
2420 kvm_debug("Emulate RI not supported @ %p: %#x\n",
2421 opc, inst.word);
2422 goto emulate_ri;
2423 }
2424
2425 return EMULATE_DONE;
2426
2427 emulate_ri:
2428 /*
2429 * Rollback PC (if in branch delay slot then the PC already points to
2430 * branch target), and pass the RI exception to the guest OS.
2431 */
2432 vcpu->arch.pc = curr_pc;
2433 return kvm_mips_emulate_ri_exc(cause, opc, run, vcpu);
2434 }
2435
2436 enum emulation_result kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu,
2437 struct kvm_run *run)
2438 {
2439 unsigned long *gpr = &vcpu->arch.gprs[vcpu->arch.io_gpr];
2440 enum emulation_result er = EMULATE_DONE;
2441
2442 if (run->mmio.len > sizeof(*gpr)) {
2443 kvm_err("Bad MMIO length: %d", run->mmio.len);
2444 er = EMULATE_FAIL;
2445 goto done;
2446 }
2447
2448 er = update_pc(vcpu, vcpu->arch.pending_load_cause);
2449 if (er == EMULATE_FAIL)
2450 return er;
2451
2452 switch (run->mmio.len) {
2453 case 4:
2454 *gpr = *(s32 *) run->mmio.data;
2455 break;
2456
2457 case 2:
2458 if (vcpu->mmio_needed == 2)
2459 *gpr = *(s16 *) run->mmio.data;
2460 else
2461 *gpr = *(u16 *)run->mmio.data;
2462
2463 break;
2464 case 1:
2465 if (vcpu->mmio_needed == 2)
2466 *gpr = *(s8 *) run->mmio.data;
2467 else
2468 *gpr = *(u8 *) run->mmio.data;
2469 break;
2470 }
2471
2472 if (vcpu->arch.pending_load_cause & CAUSEF_BD)
2473 kvm_debug("[%#lx] Completing %d byte BD Load to gpr %d (0x%08lx) type %d\n",
2474 vcpu->arch.pc, run->mmio.len, vcpu->arch.io_gpr, *gpr,
2475 vcpu->mmio_needed);
2476
2477 done:
2478 return er;
2479 }
2480
2481 static enum emulation_result kvm_mips_emulate_exc(u32 cause,
2482 u32 *opc,
2483 struct kvm_run *run,
2484 struct kvm_vcpu *vcpu)
2485 {
2486 u32 exccode = (cause >> CAUSEB_EXCCODE) & 0x1f;
2487 struct mips_coproc *cop0 = vcpu->arch.cop0;
2488 struct kvm_vcpu_arch *arch = &vcpu->arch;
2489 enum emulation_result er = EMULATE_DONE;
2490
2491 if ((kvm_read_c0_guest_status(cop0) & ST0_EXL) == 0) {
2492 /* save old pc */
2493 kvm_write_c0_guest_epc(cop0, arch->pc);
2494 kvm_set_c0_guest_status(cop0, ST0_EXL);
2495
2496 if (cause & CAUSEF_BD)
2497 kvm_set_c0_guest_cause(cop0, CAUSEF_BD);
2498 else
2499 kvm_clear_c0_guest_cause(cop0, CAUSEF_BD);
2500
2501 kvm_change_c0_guest_cause(cop0, (0xff),
2502 (exccode << CAUSEB_EXCCODE));
2503
2504 /* Set PC to the exception entry point */
2505 arch->pc = KVM_GUEST_KSEG0 + 0x180;
2506 kvm_write_c0_guest_badvaddr(cop0, vcpu->arch.host_cp0_badvaddr);
2507
2508 kvm_debug("Delivering EXC %d @ pc %#lx, badVaddr: %#lx\n",
2509 exccode, kvm_read_c0_guest_epc(cop0),
2510 kvm_read_c0_guest_badvaddr(cop0));
2511 } else {
2512 kvm_err("Trying to deliver EXC when EXL is already set\n");
2513 er = EMULATE_FAIL;
2514 }
2515
2516 return er;
2517 }
2518
2519 enum emulation_result kvm_mips_check_privilege(u32 cause,
2520 u32 *opc,
2521 struct kvm_run *run,
2522 struct kvm_vcpu *vcpu)
2523 {
2524 enum emulation_result er = EMULATE_DONE;
2525 u32 exccode = (cause >> CAUSEB_EXCCODE) & 0x1f;
2526 unsigned long badvaddr = vcpu->arch.host_cp0_badvaddr;
2527
2528 int usermode = !KVM_GUEST_KERNEL_MODE(vcpu);
2529
2530 if (usermode) {
2531 switch (exccode) {
2532 case EXCCODE_INT:
2533 case EXCCODE_SYS:
2534 case EXCCODE_BP:
2535 case EXCCODE_RI:
2536 case EXCCODE_TR:
2537 case EXCCODE_MSAFPE:
2538 case EXCCODE_FPE:
2539 case EXCCODE_MSADIS:
2540 break;
2541
2542 case EXCCODE_CPU:
2543 if (((cause & CAUSEF_CE) >> CAUSEB_CE) == 0)
2544 er = EMULATE_PRIV_FAIL;
2545 break;
2546
2547 case EXCCODE_MOD:
2548 break;
2549
2550 case EXCCODE_TLBL:
2551 /*
2552 * We we are accessing Guest kernel space, then send an
2553 * address error exception to the guest
2554 */
2555 if (badvaddr >= (unsigned long) KVM_GUEST_KSEG0) {
2556 kvm_debug("%s: LD MISS @ %#lx\n", __func__,
2557 badvaddr);
2558 cause &= ~0xff;
2559 cause |= (EXCCODE_ADEL << CAUSEB_EXCCODE);
2560 er = EMULATE_PRIV_FAIL;
2561 }
2562 break;
2563
2564 case EXCCODE_TLBS:
2565 /*
2566 * We we are accessing Guest kernel space, then send an
2567 * address error exception to the guest
2568 */
2569 if (badvaddr >= (unsigned long) KVM_GUEST_KSEG0) {
2570 kvm_debug("%s: ST MISS @ %#lx\n", __func__,
2571 badvaddr);
2572 cause &= ~0xff;
2573 cause |= (EXCCODE_ADES << CAUSEB_EXCCODE);
2574 er = EMULATE_PRIV_FAIL;
2575 }
2576 break;
2577
2578 case EXCCODE_ADES:
2579 kvm_debug("%s: address error ST @ %#lx\n", __func__,
2580 badvaddr);
2581 if ((badvaddr & PAGE_MASK) == KVM_GUEST_COMMPAGE_ADDR) {
2582 cause &= ~0xff;
2583 cause |= (EXCCODE_TLBS << CAUSEB_EXCCODE);
2584 }
2585 er = EMULATE_PRIV_FAIL;
2586 break;
2587 case EXCCODE_ADEL:
2588 kvm_debug("%s: address error LD @ %#lx\n", __func__,
2589 badvaddr);
2590 if ((badvaddr & PAGE_MASK) == KVM_GUEST_COMMPAGE_ADDR) {
2591 cause &= ~0xff;
2592 cause |= (EXCCODE_TLBL << CAUSEB_EXCCODE);
2593 }
2594 er = EMULATE_PRIV_FAIL;
2595 break;
2596 default:
2597 er = EMULATE_PRIV_FAIL;
2598 break;
2599 }
2600 }
2601
2602 if (er == EMULATE_PRIV_FAIL)
2603 kvm_mips_emulate_exc(cause, opc, run, vcpu);
2604
2605 return er;
2606 }
2607
2608 /*
2609 * User Address (UA) fault, this could happen if
2610 * (1) TLB entry not present/valid in both Guest and shadow host TLBs, in this
2611 * case we pass on the fault to the guest kernel and let it handle it.
2612 * (2) TLB entry is present in the Guest TLB but not in the shadow, in this
2613 * case we inject the TLB from the Guest TLB into the shadow host TLB
2614 */
2615 enum emulation_result kvm_mips_handle_tlbmiss(u32 cause,
2616 u32 *opc,
2617 struct kvm_run *run,
2618 struct kvm_vcpu *vcpu)
2619 {
2620 enum emulation_result er = EMULATE_DONE;
2621 u32 exccode = (cause >> CAUSEB_EXCCODE) & 0x1f;
2622 unsigned long va = vcpu->arch.host_cp0_badvaddr;
2623 int index;
2624
2625 kvm_debug("kvm_mips_handle_tlbmiss: badvaddr: %#lx\n",
2626 vcpu->arch.host_cp0_badvaddr);
2627
2628 /*
2629 * KVM would not have got the exception if this entry was valid in the
2630 * shadow host TLB. Check the Guest TLB, if the entry is not there then
2631 * send the guest an exception. The guest exc handler should then inject
2632 * an entry into the guest TLB.
2633 */
2634 index = kvm_mips_guest_tlb_lookup(vcpu,
2635 (va & VPN2_MASK) |
2636 (kvm_read_c0_guest_entryhi(vcpu->arch.cop0) &
2637 KVM_ENTRYHI_ASID));
2638 if (index < 0) {
2639 if (exccode == EXCCODE_TLBL) {
2640 er = kvm_mips_emulate_tlbmiss_ld(cause, opc, run, vcpu);
2641 } else if (exccode == EXCCODE_TLBS) {
2642 er = kvm_mips_emulate_tlbmiss_st(cause, opc, run, vcpu);
2643 } else {
2644 kvm_err("%s: invalid exc code: %d\n", __func__,
2645 exccode);
2646 er = EMULATE_FAIL;
2647 }
2648 } else {
2649 struct kvm_mips_tlb *tlb = &vcpu->arch.guest_tlb[index];
2650
2651 /*
2652 * Check if the entry is valid, if not then setup a TLB invalid
2653 * exception to the guest
2654 */
2655 if (!TLB_IS_VALID(*tlb, va)) {
2656 if (exccode == EXCCODE_TLBL) {
2657 er = kvm_mips_emulate_tlbinv_ld(cause, opc, run,
2658 vcpu);
2659 } else if (exccode == EXCCODE_TLBS) {
2660 er = kvm_mips_emulate_tlbinv_st(cause, opc, run,
2661 vcpu);
2662 } else {
2663 kvm_err("%s: invalid exc code: %d\n", __func__,
2664 exccode);
2665 er = EMULATE_FAIL;
2666 }
2667 } else {
2668 kvm_debug("Injecting hi: %#lx, lo0: %#lx, lo1: %#lx into shadow host TLB\n",
2669 tlb->tlb_hi, tlb->tlb_lo[0], tlb->tlb_lo[1]);
2670 /*
2671 * OK we have a Guest TLB entry, now inject it into the
2672 * shadow host TLB
2673 */
2674 if (kvm_mips_handle_mapped_seg_tlb_fault(vcpu, tlb)) {
2675 kvm_err("%s: handling mapped seg tlb fault for %lx, index: %u, vcpu: %p, ASID: %#lx\n",
2676 __func__, va, index, vcpu,
2677 read_c0_entryhi());
2678 er = EMULATE_FAIL;
2679 }
2680 }
2681 }
2682
2683 return er;
2684 }
Linux kernel - Deliverables
This page took 0.15723 seconds and 4 git commands to generate.