2008-04-17 04:28:09 +00:00
|
|
|
/*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License, version 2, as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
|
*
|
|
|
|
|
* Copyright IBM Corp. 2007
|
2011-06-14 23:34:31 +00:00
|
|
|
* Copyright 2010-2011 Freescale Semiconductor, Inc.
|
2008-04-17 04:28:09 +00:00
|
|
|
*
|
|
|
|
|
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
|
|
|
|
* Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
|
2011-12-20 15:34:43 +00:00
|
|
|
* Scott Wood <scottwood@freescale.com>
|
|
|
|
|
* Varun Sethi <varun.sethi@freescale.com>
|
2008-04-17 04:28:09 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/kvm_host.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/gfp.h>
|
2008-04-17 04:28:09 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
|
#include <linux/fs.h>
|
2008-12-02 21:51:55 +00:00
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
#include <asm/cputable.h>
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
#include <asm/kvm_ppc.h>
|
2008-11-05 15:36:13 +00:00
|
|
|
#include <asm/cacheflush.h>
|
2011-12-20 15:34:43 +00:00
|
|
|
#include <asm/dbell.h>
|
|
|
|
|
#include <asm/hw_irq.h>
|
|
|
|
|
#include <asm/irq.h>
|
2012-10-11 06:13:19 +00:00
|
|
|
#include <asm/time.h>
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
#include "timing.h"
|
2008-11-05 15:36:16 +00:00
|
|
|
#include "booke.h"
|
2012-08-02 13:10:00 +00:00
|
|
|
#include "trace.h"
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2008-11-05 15:36:13 +00:00
|
|
|
unsigned long kvmppc_booke_handlers;
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
#define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM
|
|
|
|
|
#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
|
|
|
|
|
|
|
|
|
|
struct kvm_stats_debugfs_item debugfs_entries[] = {
|
|
|
|
|
{ "mmio", VCPU_STAT(mmio_exits) },
|
|
|
|
|
{ "dcr", VCPU_STAT(dcr_exits) },
|
|
|
|
|
{ "sig", VCPU_STAT(signal_exits) },
|
|
|
|
|
{ "itlb_r", VCPU_STAT(itlb_real_miss_exits) },
|
|
|
|
|
{ "itlb_v", VCPU_STAT(itlb_virt_miss_exits) },
|
|
|
|
|
{ "dtlb_r", VCPU_STAT(dtlb_real_miss_exits) },
|
|
|
|
|
{ "dtlb_v", VCPU_STAT(dtlb_virt_miss_exits) },
|
|
|
|
|
{ "sysc", VCPU_STAT(syscall_exits) },
|
|
|
|
|
{ "isi", VCPU_STAT(isi_exits) },
|
|
|
|
|
{ "dsi", VCPU_STAT(dsi_exits) },
|
|
|
|
|
{ "inst_emu", VCPU_STAT(emulated_inst_exits) },
|
|
|
|
|
{ "dec", VCPU_STAT(dec_exits) },
|
|
|
|
|
{ "ext_intr", VCPU_STAT(ext_intr_exits) },
|
2008-04-25 22:55:49 +00:00
|
|
|
{ "halt_wakeup", VCPU_STAT(halt_wakeup) },
|
2011-12-20 15:34:43 +00:00
|
|
|
{ "doorbell", VCPU_STAT(dbell_exits) },
|
|
|
|
|
{ "guest doorbell", VCPU_STAT(gdbell_exits) },
|
2012-08-01 10:56:51 +00:00
|
|
|
{ "remote_tlb_flush", VM_STAT(remote_tlb_flush) },
|
2008-04-17 04:28:09 +00:00
|
|
|
{ NULL }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* TODO: use vcpu_printf() */
|
|
|
|
|
void kvmppc_dump_vcpu(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2010-07-29 12:47:43 +00:00
|
|
|
printk("pc: %08lx msr: %08llx\n", vcpu->arch.pc, vcpu->arch.shared->msr);
|
2008-11-05 15:36:19 +00:00
|
|
|
printk("lr: %08lx ctr: %08lx\n", vcpu->arch.lr, vcpu->arch.ctr);
|
2010-07-29 12:47:46 +00:00
|
|
|
printk("srr0: %08llx srr1: %08llx\n", vcpu->arch.shared->srr0,
|
|
|
|
|
vcpu->arch.shared->srr1);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
printk("exceptions: %08lx\n", vcpu->arch.pending_exceptions);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 32; i += 4) {
|
2008-11-05 15:36:19 +00:00
|
|
|
printk("gpr%02d: %08lx %08lx %08lx %08lx\n", i,
|
2010-01-08 01:58:01 +00:00
|
|
|
kvmppc_get_gpr(vcpu, i),
|
|
|
|
|
kvmppc_get_gpr(vcpu, i+1),
|
|
|
|
|
kvmppc_get_gpr(vcpu, i+2),
|
|
|
|
|
kvmppc_get_gpr(vcpu, i+3));
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-14 23:34:31 +00:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
|
void kvmppc_vcpu_disable_spe(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
preempt_disable();
|
|
|
|
|
enable_kernel_spe();
|
|
|
|
|
kvmppc_save_guest_spe(vcpu);
|
|
|
|
|
vcpu->arch.shadow_msr &= ~MSR_SPE;
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_vcpu_enable_spe(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
preempt_disable();
|
|
|
|
|
enable_kernel_spe();
|
|
|
|
|
kvmppc_load_guest_spe(vcpu);
|
|
|
|
|
vcpu->arch.shadow_msr |= MSR_SPE;
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_vcpu_sync_spe(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
if (vcpu->arch.shared->msr & MSR_SPE) {
|
|
|
|
|
if (!(vcpu->arch.shadow_msr & MSR_SPE))
|
|
|
|
|
kvmppc_vcpu_enable_spe(vcpu);
|
|
|
|
|
} else if (vcpu->arch.shadow_msr & MSR_SPE) {
|
|
|
|
|
kvmppc_vcpu_disable_spe(vcpu);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static void kvmppc_vcpu_sync_spe(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-08-16 11:10:16 +00:00
|
|
|
static void kvmppc_vcpu_sync_fpu(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
#if defined(CONFIG_PPC_FPU) && !defined(CONFIG_KVM_BOOKE_HV)
|
|
|
|
|
/* We always treat the FP bit as enabled from the host
|
|
|
|
|
perspective, so only need to adjust the shadow MSR */
|
|
|
|
|
vcpu->arch.shadow_msr &= ~MSR_FP;
|
|
|
|
|
vcpu->arch.shadow_msr |= vcpu->arch.shared->msr & MSR_FP;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-14 23:35:14 +00:00
|
|
|
/*
|
|
|
|
|
* Helper function for "full" MSR writes. No need to call this if only
|
|
|
|
|
* EE/CE/ME/DE/RI are changing.
|
|
|
|
|
*/
|
2011-06-14 23:34:31 +00:00
|
|
|
void kvmppc_set_msr(struct kvm_vcpu *vcpu, u32 new_msr)
|
|
|
|
|
{
|
2011-06-14 23:35:14 +00:00
|
|
|
u32 old_msr = vcpu->arch.shared->msr;
|
2011-06-14 23:34:31 +00:00
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
new_msr |= MSR_GS;
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-06-14 23:34:31 +00:00
|
|
|
vcpu->arch.shared->msr = new_msr;
|
|
|
|
|
|
2011-06-14 23:35:14 +00:00
|
|
|
kvmppc_mmu_msr_notify(vcpu, old_msr);
|
2011-06-14 23:34:31 +00:00
|
|
|
kvmppc_vcpu_sync_spe(vcpu);
|
2012-08-16 11:10:16 +00:00
|
|
|
kvmppc_vcpu_sync_fpu(vcpu);
|
2011-06-14 23:34:31 +00:00
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
static void kvmppc_booke_queue_irqprio(struct kvm_vcpu *vcpu,
|
|
|
|
|
unsigned int priority)
|
2008-11-05 15:36:14 +00:00
|
|
|
{
|
2012-08-07 22:44:52 +00:00
|
|
|
trace_kvm_booke_queue_irqprio(vcpu, priority);
|
2008-11-05 15:36:14 +00:00
|
|
|
set_bit(priority, &vcpu->arch.pending_exceptions);
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-02 11:44:35 +00:00
|
|
|
static void kvmppc_core_queue_dtlb_miss(struct kvm_vcpu *vcpu,
|
|
|
|
|
ulong dear_flags, ulong esr_flags)
|
2008-11-05 15:36:14 +00:00
|
|
|
{
|
2010-02-02 11:44:35 +00:00
|
|
|
vcpu->arch.queued_dear = dear_flags;
|
|
|
|
|
vcpu->arch.queued_esr = esr_flags;
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_DTLB_MISS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_core_queue_data_storage(struct kvm_vcpu *vcpu,
|
|
|
|
|
ulong dear_flags, ulong esr_flags)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.queued_dear = dear_flags;
|
|
|
|
|
vcpu->arch.queued_esr = esr_flags;
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_DATA_STORAGE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_core_queue_inst_storage(struct kvm_vcpu *vcpu,
|
|
|
|
|
ulong esr_flags)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.queued_esr = esr_flags;
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_INST_STORAGE);
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-31 13:17:38 +00:00
|
|
|
static void kvmppc_core_queue_alignment(struct kvm_vcpu *vcpu, ulong dear_flags,
|
|
|
|
|
ulong esr_flags)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.queued_dear = dear_flags;
|
|
|
|
|
vcpu->arch.queued_esr = esr_flags;
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_ALIGNMENT);
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-02 11:44:35 +00:00
|
|
|
void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong esr_flags)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.queued_esr = esr_flags;
|
2008-11-05 15:36:23 +00:00
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_PROGRAM);
|
2008-11-05 15:36:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_core_queue_dec(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2008-11-05 15:36:23 +00:00
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_DECREMENTER);
|
2008-11-05 15:36:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvmppc_core_pending_dec(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2008-11-05 15:36:23 +00:00
|
|
|
return test_bit(BOOKE_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions);
|
2008-11-05 15:36:14 +00:00
|
|
|
}
|
|
|
|
|
|
2009-12-21 19:21:24 +00:00
|
|
|
void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
clear_bit(BOOKE_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions);
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:14 +00:00
|
|
|
void kvmppc_core_queue_external(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_interrupt *irq)
|
|
|
|
|
{
|
2010-08-30 12:03:24 +00:00
|
|
|
unsigned int prio = BOOKE_IRQPRIO_EXTERNAL;
|
|
|
|
|
|
|
|
|
|
if (irq->irq == KVM_INTERRUPT_SET_LEVEL)
|
|
|
|
|
prio = BOOKE_IRQPRIO_EXTERNAL_LEVEL;
|
|
|
|
|
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, prio);
|
2008-11-05 15:36:14 +00:00
|
|
|
}
|
|
|
|
|
|
2013-02-14 14:00:25 +00:00
|
|
|
void kvmppc_core_dequeue_external(struct kvm_vcpu *vcpu)
|
2010-04-07 08:03:25 +00:00
|
|
|
{
|
|
|
|
|
clear_bit(BOOKE_IRQPRIO_EXTERNAL, &vcpu->arch.pending_exceptions);
|
2010-08-30 12:03:24 +00:00
|
|
|
clear_bit(BOOKE_IRQPRIO_EXTERNAL_LEVEL, &vcpu->arch.pending_exceptions);
|
2010-04-07 08:03:25 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-08 20:38:19 +00:00
|
|
|
static void kvmppc_core_queue_watchdog(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_WATCHDOG);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_core_dequeue_watchdog(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
clear_bit(BOOKE_IRQPRIO_WATCHDOG, &vcpu->arch.pending_exceptions);
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
static void set_guest_srr(struct kvm_vcpu *vcpu, unsigned long srr0, u32 srr1)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
mtspr(SPRN_GSRR0, srr0);
|
|
|
|
|
mtspr(SPRN_GSRR1, srr1);
|
|
|
|
|
#else
|
|
|
|
|
vcpu->arch.shared->srr0 = srr0;
|
|
|
|
|
vcpu->arch.shared->srr1 = srr1;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_guest_csrr(struct kvm_vcpu *vcpu, unsigned long srr0, u32 srr1)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.csrr0 = srr0;
|
|
|
|
|
vcpu->arch.csrr1 = srr1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_guest_dsrr(struct kvm_vcpu *vcpu, unsigned long srr0, u32 srr1)
|
|
|
|
|
{
|
|
|
|
|
if (cpu_has_feature(CPU_FTR_DEBUG_LVL_EXC)) {
|
|
|
|
|
vcpu->arch.dsrr0 = srr0;
|
|
|
|
|
vcpu->arch.dsrr1 = srr1;
|
|
|
|
|
} else {
|
|
|
|
|
set_guest_csrr(vcpu, srr0, srr1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_guest_mcsrr(struct kvm_vcpu *vcpu, unsigned long srr0, u32 srr1)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.mcsrr0 = srr0;
|
|
|
|
|
vcpu->arch.mcsrr1 = srr1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long get_guest_dear(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
return mfspr(SPRN_GDEAR);
|
|
|
|
|
#else
|
|
|
|
|
return vcpu->arch.shared->dar;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_guest_dear(struct kvm_vcpu *vcpu, unsigned long dear)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
mtspr(SPRN_GDEAR, dear);
|
|
|
|
|
#else
|
|
|
|
|
vcpu->arch.shared->dar = dear;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long get_guest_esr(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
return mfspr(SPRN_GESR);
|
|
|
|
|
#else
|
|
|
|
|
return vcpu->arch.shared->esr;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_guest_esr(struct kvm_vcpu *vcpu, u32 esr)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
mtspr(SPRN_GESR, esr);
|
|
|
|
|
#else
|
|
|
|
|
vcpu->arch.shared->esr = esr;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-04 17:28:51 +00:00
|
|
|
static unsigned long get_guest_epr(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
return mfspr(SPRN_GEPR);
|
|
|
|
|
#else
|
|
|
|
|
return vcpu->arch.epr;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
/* Deliver the interrupt of the corresponding priority, if possible. */
|
|
|
|
|
static int kvmppc_booke_irqprio_deliver(struct kvm_vcpu *vcpu,
|
|
|
|
|
unsigned int priority)
|
2008-04-17 04:28:09 +00:00
|
|
|
{
|
2008-11-05 15:36:23 +00:00
|
|
|
int allowed = 0;
|
2012-02-15 19:12:29 +00:00
|
|
|
ulong msr_mask = 0;
|
2013-01-04 17:12:48 +00:00
|
|
|
bool update_esr = false, update_dear = false, update_epr = false;
|
2010-07-29 12:47:49 +00:00
|
|
|
ulong crit_raw = vcpu->arch.shared->critical;
|
|
|
|
|
ulong crit_r1 = kvmppc_get_gpr(vcpu, 1);
|
|
|
|
|
bool crit;
|
2010-08-30 12:03:24 +00:00
|
|
|
bool keep_irq = false;
|
2011-12-20 15:34:43 +00:00
|
|
|
enum int_class int_class;
|
2012-10-11 06:13:26 +00:00
|
|
|
ulong new_msr = vcpu->arch.shared->msr;
|
2010-07-29 12:47:49 +00:00
|
|
|
|
|
|
|
|
/* Truncate crit indicators in 32 bit mode */
|
|
|
|
|
if (!(vcpu->arch.shared->msr & MSR_SF)) {
|
|
|
|
|
crit_raw &= 0xffffffff;
|
|
|
|
|
crit_r1 &= 0xffffffff;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Critical section when crit == r1 */
|
|
|
|
|
crit = (crit_raw == crit_r1);
|
|
|
|
|
/* ... and we're in supervisor mode */
|
|
|
|
|
crit = crit && !(vcpu->arch.shared->msr & MSR_PR);
|
2008-11-05 15:36:23 +00:00
|
|
|
|
2010-08-30 12:03:24 +00:00
|
|
|
if (priority == BOOKE_IRQPRIO_EXTERNAL_LEVEL) {
|
|
|
|
|
priority = BOOKE_IRQPRIO_EXTERNAL;
|
|
|
|
|
keep_irq = true;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-04 17:12:48 +00:00
|
|
|
if ((priority == BOOKE_IRQPRIO_EXTERNAL) && vcpu->arch.epr_enabled)
|
|
|
|
|
update_epr = true;
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
switch (priority) {
|
|
|
|
|
case BOOKE_IRQPRIO_DTLB_MISS:
|
|
|
|
|
case BOOKE_IRQPRIO_DATA_STORAGE:
|
2013-01-31 13:17:38 +00:00
|
|
|
case BOOKE_IRQPRIO_ALIGNMENT:
|
2010-02-02 11:44:35 +00:00
|
|
|
update_dear = true;
|
|
|
|
|
/* fall through */
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_INST_STORAGE:
|
2010-02-02 11:44:35 +00:00
|
|
|
case BOOKE_IRQPRIO_PROGRAM:
|
|
|
|
|
update_esr = true;
|
|
|
|
|
/* fall through */
|
|
|
|
|
case BOOKE_IRQPRIO_ITLB_MISS:
|
|
|
|
|
case BOOKE_IRQPRIO_SYSCALL:
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_FP_UNAVAIL:
|
2009-01-03 22:23:13 +00:00
|
|
|
case BOOKE_IRQPRIO_SPE_UNAVAIL:
|
|
|
|
|
case BOOKE_IRQPRIO_SPE_FP_DATA:
|
|
|
|
|
case BOOKE_IRQPRIO_SPE_FP_ROUND:
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_AP_UNAVAIL:
|
|
|
|
|
allowed = 1;
|
2012-02-15 19:12:29 +00:00
|
|
|
msr_mask = MSR_CE | MSR_ME | MSR_DE;
|
2011-12-20 15:34:43 +00:00
|
|
|
int_class = INT_CLASS_NONCRIT;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
2012-08-08 20:38:19 +00:00
|
|
|
case BOOKE_IRQPRIO_WATCHDOG:
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_CRITICAL:
|
2012-02-15 13:28:48 +00:00
|
|
|
case BOOKE_IRQPRIO_DBELL_CRIT:
|
2010-07-29 12:47:43 +00:00
|
|
|
allowed = vcpu->arch.shared->msr & MSR_CE;
|
2011-12-20 15:34:43 +00:00
|
|
|
allowed = allowed && !crit;
|
2012-02-15 19:12:29 +00:00
|
|
|
msr_mask = MSR_ME;
|
2011-12-20 15:34:43 +00:00
|
|
|
int_class = INT_CLASS_CRIT;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_MACHINE_CHECK:
|
2010-07-29 12:47:43 +00:00
|
|
|
allowed = vcpu->arch.shared->msr & MSR_ME;
|
2011-12-20 15:34:43 +00:00
|
|
|
allowed = allowed && !crit;
|
|
|
|
|
int_class = INT_CLASS_MC;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_DECREMENTER:
|
|
|
|
|
case BOOKE_IRQPRIO_FIT:
|
2011-11-17 12:39:59 +00:00
|
|
|
keep_irq = true;
|
|
|
|
|
/* fall through */
|
|
|
|
|
case BOOKE_IRQPRIO_EXTERNAL:
|
2012-02-15 13:28:48 +00:00
|
|
|
case BOOKE_IRQPRIO_DBELL:
|
2010-07-29 12:47:43 +00:00
|
|
|
allowed = vcpu->arch.shared->msr & MSR_EE;
|
2010-07-29 12:47:49 +00:00
|
|
|
allowed = allowed && !crit;
|
2012-02-15 19:12:29 +00:00
|
|
|
msr_mask = MSR_CE | MSR_ME | MSR_DE;
|
2011-12-20 15:34:43 +00:00
|
|
|
int_class = INT_CLASS_NONCRIT;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
2008-11-05 15:36:23 +00:00
|
|
|
case BOOKE_IRQPRIO_DEBUG:
|
2010-07-29 12:47:43 +00:00
|
|
|
allowed = vcpu->arch.shared->msr & MSR_DE;
|
2011-12-20 15:34:43 +00:00
|
|
|
allowed = allowed && !crit;
|
2012-02-15 19:12:29 +00:00
|
|
|
msr_mask = MSR_ME;
|
2011-12-20 15:34:43 +00:00
|
|
|
int_class = INT_CLASS_CRIT;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
if (allowed) {
|
2011-12-20 15:34:43 +00:00
|
|
|
switch (int_class) {
|
|
|
|
|
case INT_CLASS_NONCRIT:
|
|
|
|
|
set_guest_srr(vcpu, vcpu->arch.pc,
|
|
|
|
|
vcpu->arch.shared->msr);
|
|
|
|
|
break;
|
|
|
|
|
case INT_CLASS_CRIT:
|
|
|
|
|
set_guest_csrr(vcpu, vcpu->arch.pc,
|
|
|
|
|
vcpu->arch.shared->msr);
|
|
|
|
|
break;
|
|
|
|
|
case INT_CLASS_DBG:
|
|
|
|
|
set_guest_dsrr(vcpu, vcpu->arch.pc,
|
|
|
|
|
vcpu->arch.shared->msr);
|
|
|
|
|
break;
|
|
|
|
|
case INT_CLASS_MC:
|
|
|
|
|
set_guest_mcsrr(vcpu, vcpu->arch.pc,
|
|
|
|
|
vcpu->arch.shared->msr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
vcpu->arch.pc = vcpu->arch.ivpr | vcpu->arch.ivor[priority];
|
2010-02-02 11:44:35 +00:00
|
|
|
if (update_esr == true)
|
2011-12-20 15:34:43 +00:00
|
|
|
set_guest_esr(vcpu, vcpu->arch.queued_esr);
|
2010-02-02 11:44:35 +00:00
|
|
|
if (update_dear == true)
|
2011-12-20 15:34:43 +00:00
|
|
|
set_guest_dear(vcpu, vcpu->arch.queued_dear);
|
2013-01-04 17:12:48 +00:00
|
|
|
if (update_epr == true)
|
|
|
|
|
kvm_make_request(KVM_REQ_EPR_EXIT, vcpu);
|
2012-10-11 06:13:26 +00:00
|
|
|
|
|
|
|
|
new_msr &= msr_mask;
|
|
|
|
|
#if defined(CONFIG_64BIT)
|
|
|
|
|
if (vcpu->arch.epcr & SPRN_EPCR_ICM)
|
|
|
|
|
new_msr |= MSR_CM;
|
|
|
|
|
#endif
|
|
|
|
|
kvmppc_set_msr(vcpu, new_msr);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2010-08-30 12:03:24 +00:00
|
|
|
if (!keep_irq)
|
|
|
|
|
clear_bit(priority, &vcpu->arch.pending_exceptions);
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
/*
|
|
|
|
|
* If an interrupt is pending but masked, raise a guest doorbell
|
|
|
|
|
* so that we are notified when the guest enables the relevant
|
|
|
|
|
* MSR bit.
|
|
|
|
|
*/
|
|
|
|
|
if (vcpu->arch.pending_exceptions & BOOKE_IRQMASK_EE)
|
|
|
|
|
kvmppc_set_pending_interrupt(vcpu, INT_CLASS_NONCRIT);
|
|
|
|
|
if (vcpu->arch.pending_exceptions & BOOKE_IRQMASK_CE)
|
|
|
|
|
kvmppc_set_pending_interrupt(vcpu, INT_CLASS_CRIT);
|
|
|
|
|
if (vcpu->arch.pending_exceptions & BOOKE_IRQPRIO_MACHINE_CHECK)
|
|
|
|
|
kvmppc_set_pending_interrupt(vcpu, INT_CLASS_MC);
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-11-05 15:36:23 +00:00
|
|
|
return allowed;
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-08 20:38:19 +00:00
|
|
|
/*
|
|
|
|
|
* Return the number of jiffies until the next timeout. If the timeout is
|
|
|
|
|
* longer than the NEXT_TIMER_MAX_DELTA, then return NEXT_TIMER_MAX_DELTA
|
|
|
|
|
* because the larger value can break the timer APIs.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned long watchdog_next_timeout(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
u64 tb, wdt_tb, wdt_ticks = 0;
|
|
|
|
|
u64 nr_jiffies = 0;
|
|
|
|
|
u32 period = TCR_GET_WP(vcpu->arch.tcr);
|
|
|
|
|
|
|
|
|
|
wdt_tb = 1ULL << (63 - period);
|
|
|
|
|
tb = get_tb();
|
|
|
|
|
/*
|
|
|
|
|
* The watchdog timeout will hapeen when TB bit corresponding
|
|
|
|
|
* to watchdog will toggle from 0 to 1.
|
|
|
|
|
*/
|
|
|
|
|
if (tb & wdt_tb)
|
|
|
|
|
wdt_ticks = wdt_tb;
|
|
|
|
|
|
|
|
|
|
wdt_ticks += wdt_tb - (tb & (wdt_tb - 1));
|
|
|
|
|
|
|
|
|
|
/* Convert timebase ticks to jiffies */
|
|
|
|
|
nr_jiffies = wdt_ticks;
|
|
|
|
|
|
|
|
|
|
if (do_div(nr_jiffies, tb_ticks_per_jiffy))
|
|
|
|
|
nr_jiffies++;
|
|
|
|
|
|
|
|
|
|
return min_t(unsigned long long, nr_jiffies, NEXT_TIMER_MAX_DELTA);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void arm_next_watchdog(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
unsigned long nr_jiffies;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If TSR_ENW and TSR_WIS are not set then no need to exit to
|
|
|
|
|
* userspace, so clear the KVM_REQ_WATCHDOG request.
|
|
|
|
|
*/
|
|
|
|
|
if ((vcpu->arch.tsr & (TSR_ENW | TSR_WIS)) != (TSR_ENW | TSR_WIS))
|
|
|
|
|
clear_bit(KVM_REQ_WATCHDOG, &vcpu->requests);
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vcpu->arch.wdt_lock, flags);
|
|
|
|
|
nr_jiffies = watchdog_next_timeout(vcpu);
|
|
|
|
|
/*
|
|
|
|
|
* If the number of jiffies of watchdog timer >= NEXT_TIMER_MAX_DELTA
|
|
|
|
|
* then do not run the watchdog timer as this can break timer APIs.
|
|
|
|
|
*/
|
|
|
|
|
if (nr_jiffies < NEXT_TIMER_MAX_DELTA)
|
|
|
|
|
mod_timer(&vcpu->arch.wdt_timer, jiffies + nr_jiffies);
|
|
|
|
|
else
|
|
|
|
|
del_timer(&vcpu->arch.wdt_timer);
|
|
|
|
|
spin_unlock_irqrestore(&vcpu->arch.wdt_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_watchdog_func(unsigned long data)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
|
|
|
|
|
u32 tsr, new_tsr;
|
|
|
|
|
int final;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
new_tsr = tsr = vcpu->arch.tsr;
|
|
|
|
|
final = 0;
|
|
|
|
|
|
|
|
|
|
/* Time out event */
|
|
|
|
|
if (tsr & TSR_ENW) {
|
|
|
|
|
if (tsr & TSR_WIS)
|
|
|
|
|
final = 1;
|
|
|
|
|
else
|
|
|
|
|
new_tsr = tsr | TSR_WIS;
|
|
|
|
|
} else {
|
|
|
|
|
new_tsr = tsr | TSR_ENW;
|
|
|
|
|
}
|
|
|
|
|
} while (cmpxchg(&vcpu->arch.tsr, tsr, new_tsr) != tsr);
|
|
|
|
|
|
|
|
|
|
if (new_tsr & TSR_WIS) {
|
|
|
|
|
smp_wmb();
|
|
|
|
|
kvm_make_request(KVM_REQ_PENDING_TIMER, vcpu);
|
|
|
|
|
kvm_vcpu_kick(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If this is final watchdog expiry and some action is required
|
|
|
|
|
* then exit to userspace.
|
|
|
|
|
*/
|
|
|
|
|
if (final && (vcpu->arch.tcr & TCR_WRC_MASK) &&
|
|
|
|
|
vcpu->arch.watchdog_enabled) {
|
|
|
|
|
smp_wmb();
|
|
|
|
|
kvm_make_request(KVM_REQ_WATCHDOG, vcpu);
|
|
|
|
|
kvm_vcpu_kick(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Stop running the watchdog timer after final expiration to
|
|
|
|
|
* prevent the host from being flooded with timers if the
|
|
|
|
|
* guest sets a short period.
|
|
|
|
|
* Timers will resume when TSR/TCR is updated next time.
|
|
|
|
|
*/
|
|
|
|
|
if (!final)
|
|
|
|
|
arm_next_watchdog(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-17 12:39:59 +00:00
|
|
|
static void update_timer_ints(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
if ((vcpu->arch.tcr & TCR_DIE) && (vcpu->arch.tsr & TSR_DIS))
|
|
|
|
|
kvmppc_core_queue_dec(vcpu);
|
|
|
|
|
else
|
|
|
|
|
kvmppc_core_dequeue_dec(vcpu);
|
2012-08-08 20:38:19 +00:00
|
|
|
|
|
|
|
|
if ((vcpu->arch.tcr & TCR_WIE) && (vcpu->arch.tsr & TSR_WIS))
|
|
|
|
|
kvmppc_core_queue_watchdog(vcpu);
|
|
|
|
|
else
|
|
|
|
|
kvmppc_core_dequeue_watchdog(vcpu);
|
2011-11-17 12:39:59 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-09 00:23:25 +00:00
|
|
|
static void kvmppc_core_check_exceptions(struct kvm_vcpu *vcpu)
|
2008-04-17 04:28:09 +00:00
|
|
|
{
|
|
|
|
|
unsigned long *pending = &vcpu->arch.pending_exceptions;
|
|
|
|
|
unsigned int priority;
|
|
|
|
|
|
2008-11-05 15:36:22 +00:00
|
|
|
priority = __ffs(*pending);
|
2012-02-16 14:12:46 +00:00
|
|
|
while (priority < BOOKE_IRQPRIO_MAX) {
|
2008-11-05 15:36:23 +00:00
|
|
|
if (kvmppc_booke_irqprio_deliver(vcpu, priority))
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
priority = find_next_bit(pending,
|
|
|
|
|
BITS_PER_BYTE * sizeof(*pending),
|
|
|
|
|
priority + 1);
|
|
|
|
|
}
|
2010-07-29 12:47:51 +00:00
|
|
|
|
|
|
|
|
/* Tell the guest about our interrupt status */
|
2011-11-09 00:23:27 +00:00
|
|
|
vcpu->arch.shared->int_pending = !!*pending;
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-09 00:23:25 +00:00
|
|
|
/* Check pending exceptions and deliver one, if possible. */
|
2012-02-16 14:07:37 +00:00
|
|
|
int kvmppc_core_prepare_to_enter(struct kvm_vcpu *vcpu)
|
2011-11-09 00:23:25 +00:00
|
|
|
{
|
2012-02-16 14:07:37 +00:00
|
|
|
int r = 0;
|
2011-11-09 00:23:25 +00:00
|
|
|
WARN_ON_ONCE(!irqs_disabled());
|
|
|
|
|
|
|
|
|
|
kvmppc_core_check_exceptions(vcpu);
|
|
|
|
|
|
2012-12-20 04:52:39 +00:00
|
|
|
if (vcpu->requests) {
|
|
|
|
|
/* Exception delivery raised request; start over */
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-09 00:23:25 +00:00
|
|
|
if (vcpu->arch.shared->msr & MSR_WE) {
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
kvm_vcpu_block(vcpu);
|
2012-03-14 15:55:08 +00:00
|
|
|
clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
|
2011-11-09 00:23:25 +00:00
|
|
|
local_irq_disable();
|
|
|
|
|
|
|
|
|
|
kvmppc_set_exit_type(vcpu, EMULATED_MTMSRWE_EXITS);
|
2012-02-16 14:07:37 +00:00
|
|
|
r = 1;
|
2011-11-09 00:23:25 +00:00
|
|
|
};
|
2012-02-16 14:07:37 +00:00
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-13 10:50:35 +00:00
|
|
|
int kvmppc_core_check_requests(struct kvm_vcpu *vcpu)
|
2012-08-08 18:31:13 +00:00
|
|
|
{
|
2012-08-13 10:50:35 +00:00
|
|
|
int r = 1; /* Indicate we want to get back into the guest */
|
|
|
|
|
|
2012-08-10 10:31:12 +00:00
|
|
|
if (kvm_check_request(KVM_REQ_PENDING_TIMER, vcpu))
|
|
|
|
|
update_timer_ints(vcpu);
|
2012-07-30 22:19:50 +00:00
|
|
|
#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
|
2012-08-10 10:31:12 +00:00
|
|
|
if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu))
|
|
|
|
|
kvmppc_core_flush_tlb(vcpu);
|
2012-07-30 22:19:50 +00:00
|
|
|
#endif
|
2012-08-13 10:50:35 +00:00
|
|
|
|
2012-08-08 20:38:19 +00:00
|
|
|
if (kvm_check_request(KVM_REQ_WATCHDOG, vcpu)) {
|
|
|
|
|
vcpu->run->exit_reason = KVM_EXIT_WATCHDOG;
|
|
|
|
|
r = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-04 17:12:48 +00:00
|
|
|
if (kvm_check_request(KVM_REQ_EPR_EXIT, vcpu)) {
|
|
|
|
|
vcpu->run->epr.epr = 0;
|
|
|
|
|
vcpu->arch.epr_needed = true;
|
|
|
|
|
vcpu->run->exit_reason = KVM_EXIT_EPR;
|
|
|
|
|
r = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-13 10:50:35 +00:00
|
|
|
return r;
|
2012-08-08 18:31:13 +00:00
|
|
|
}
|
|
|
|
|
|
2011-06-29 00:19:50 +00:00
|
|
|
int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2012-08-13 10:44:41 +00:00
|
|
|
int ret, s;
|
2011-12-20 15:34:45 +00:00
|
|
|
#ifdef CONFIG_PPC_FPU
|
|
|
|
|
unsigned int fpscr;
|
|
|
|
|
int fpexc_mode;
|
|
|
|
|
u64 fpr[32];
|
|
|
|
|
#endif
|
2011-06-29 00:19:50 +00:00
|
|
|
|
2011-08-10 11:57:08 +00:00
|
|
|
if (!vcpu->arch.sane) {
|
|
|
|
|
kvm_run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-29 00:19:50 +00:00
|
|
|
local_irq_disable();
|
2012-08-13 10:44:41 +00:00
|
|
|
s = kvmppc_prepare_to_enter(vcpu);
|
|
|
|
|
if (s <= 0) {
|
2012-08-12 10:42:30 +00:00
|
|
|
local_irq_enable();
|
2012-08-13 10:44:41 +00:00
|
|
|
ret = s;
|
2011-11-08 22:11:59 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
2012-08-12 23:04:19 +00:00
|
|
|
kvmppc_lazy_ee_enable();
|
2011-11-08 22:11:59 +00:00
|
|
|
|
2011-06-29 00:19:50 +00:00
|
|
|
kvm_guest_enter();
|
2011-12-20 15:34:45 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_FPU
|
|
|
|
|
/* Save userspace FPU state in stack */
|
|
|
|
|
enable_kernel_fp();
|
|
|
|
|
memcpy(fpr, current->thread.fpr, sizeof(current->thread.fpr));
|
|
|
|
|
fpscr = current->thread.fpscr.val;
|
|
|
|
|
fpexc_mode = current->thread.fpexc_mode;
|
|
|
|
|
|
|
|
|
|
/* Restore guest FPU state to thread */
|
|
|
|
|
memcpy(current->thread.fpr, vcpu->arch.fpr, sizeof(vcpu->arch.fpr));
|
|
|
|
|
current->thread.fpscr.val = vcpu->arch.fpscr;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since we can't trap on MSR_FP in GS-mode, we consider the guest
|
|
|
|
|
* as always using the FPU. Kernel usage of FP (via
|
|
|
|
|
* enable_kernel_fp()) in this thread must not occur while
|
|
|
|
|
* vcpu->fpu_active is set.
|
|
|
|
|
*/
|
|
|
|
|
vcpu->fpu_active = 1;
|
|
|
|
|
|
|
|
|
|
kvmppc_load_guest_fp(vcpu);
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-06-29 00:19:50 +00:00
|
|
|
ret = __kvmppc_vcpu_run(kvm_run, vcpu);
|
2011-12-20 15:34:45 +00:00
|
|
|
|
2012-08-12 10:42:30 +00:00
|
|
|
/* No need for kvm_guest_exit. It's done in handle_exit.
|
|
|
|
|
We also get here with interrupts enabled. */
|
|
|
|
|
|
2011-12-20 15:34:45 +00:00
|
|
|
#ifdef CONFIG_PPC_FPU
|
|
|
|
|
kvmppc_save_guest_fp(vcpu);
|
|
|
|
|
|
|
|
|
|
vcpu->fpu_active = 0;
|
|
|
|
|
|
|
|
|
|
/* Save guest FPU state from thread */
|
|
|
|
|
memcpy(vcpu->arch.fpr, current->thread.fpr, sizeof(vcpu->arch.fpr));
|
|
|
|
|
vcpu->arch.fpscr = current->thread.fpscr.val;
|
|
|
|
|
|
|
|
|
|
/* Restore userspace FPU state from stack */
|
|
|
|
|
memcpy(current->thread.fpr, fpr, sizeof(current->thread.fpr));
|
|
|
|
|
current->thread.fpscr.val = fpscr;
|
|
|
|
|
current->thread.fpexc_mode = fpexc_mode;
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-11-08 22:11:59 +00:00
|
|
|
out:
|
2012-08-08 18:44:20 +00:00
|
|
|
vcpu->mode = OUTSIDE_GUEST_MODE;
|
2011-06-29 00:19:50 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
static int emulation_exit(struct kvm_run *run, struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
enum emulation_result er;
|
|
|
|
|
|
|
|
|
|
er = kvmppc_emulate_instruction(run, vcpu);
|
|
|
|
|
switch (er) {
|
|
|
|
|
case EMULATE_DONE:
|
|
|
|
|
/* don't overwrite subtypes, just account kvm_stats */
|
|
|
|
|
kvmppc_account_exit_stat(vcpu, EMULATED_INST_EXITS);
|
|
|
|
|
/* Future optimization: only reload non-volatiles if
|
|
|
|
|
* they were actually modified by emulation. */
|
|
|
|
|
return RESUME_GUEST_NV;
|
|
|
|
|
|
|
|
|
|
case EMULATE_DO_DCR:
|
|
|
|
|
run->exit_reason = KVM_EXIT_DCR;
|
|
|
|
|
return RESUME_HOST;
|
|
|
|
|
|
|
|
|
|
case EMULATE_FAIL:
|
|
|
|
|
printk(KERN_CRIT "%s: emulation at %lx failed (%08x)\n",
|
|
|
|
|
__func__, vcpu->arch.pc, vcpu->arch.last_inst);
|
|
|
|
|
/* For debugging, encode the failing instruction and
|
|
|
|
|
* report it to userspace. */
|
|
|
|
|
run->hw.hardware_exit_reason = ~0ULL << 32;
|
|
|
|
|
run->hw.hardware_exit_reason |= vcpu->arch.last_inst;
|
2012-02-16 13:24:03 +00:00
|
|
|
kvmppc_core_queue_program(vcpu, ESR_PIL);
|
2011-12-20 15:34:43 +00:00
|
|
|
return RESUME_HOST;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-20 22:57:26 +00:00
|
|
|
static void kvmppc_fill_pt_regs(struct pt_regs *regs)
|
2008-04-17 04:28:09 +00:00
|
|
|
{
|
2012-02-20 22:57:26 +00:00
|
|
|
ulong r1, ip, msr, lr;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2012-02-20 22:57:26 +00:00
|
|
|
asm("mr %0, 1" : "=r"(r1));
|
|
|
|
|
asm("mflr %0" : "=r"(lr));
|
|
|
|
|
asm("mfmsr %0" : "=r"(msr));
|
|
|
|
|
asm("bl 1f; 1: mflr %0" : "=r"(ip));
|
|
|
|
|
|
|
|
|
|
memset(regs, 0, sizeof(*regs));
|
|
|
|
|
regs->gpr[1] = r1;
|
|
|
|
|
regs->nip = ip;
|
|
|
|
|
regs->msr = msr;
|
|
|
|
|
regs->link = lr;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-20 05:56:53 +00:00
|
|
|
/*
|
|
|
|
|
* For interrupts needed to be handled by host interrupt handlers,
|
|
|
|
|
* corresponding host handler are called from here in similar way
|
|
|
|
|
* (but not exact) as they are called from low level handler
|
|
|
|
|
* (such as from arch/powerpc/kernel/head_fsl_booke.S).
|
|
|
|
|
*/
|
2012-02-20 22:57:26 +00:00
|
|
|
static void kvmppc_restart_interrupt(struct kvm_vcpu *vcpu,
|
|
|
|
|
unsigned int exit_nr)
|
|
|
|
|
{
|
|
|
|
|
struct pt_regs regs;
|
2008-12-02 21:51:57 +00:00
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
switch (exit_nr) {
|
|
|
|
|
case BOOKE_INTERRUPT_EXTERNAL:
|
2012-02-20 22:57:26 +00:00
|
|
|
kvmppc_fill_pt_regs(®s);
|
|
|
|
|
do_IRQ(®s);
|
2011-12-20 15:34:43 +00:00
|
|
|
break;
|
|
|
|
|
case BOOKE_INTERRUPT_DECREMENTER:
|
2012-02-20 22:57:26 +00:00
|
|
|
kvmppc_fill_pt_regs(®s);
|
|
|
|
|
timer_interrupt(®s);
|
2011-12-20 15:34:43 +00:00
|
|
|
break;
|
|
|
|
|
#if defined(CONFIG_PPC_FSL_BOOK3E) || defined(CONFIG_PPC_BOOK3E_64)
|
|
|
|
|
case BOOKE_INTERRUPT_DOORBELL:
|
2012-02-20 22:57:26 +00:00
|
|
|
kvmppc_fill_pt_regs(®s);
|
|
|
|
|
doorbell_exception(®s);
|
2011-12-20 15:34:43 +00:00
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
case BOOKE_INTERRUPT_MACHINE_CHECK:
|
|
|
|
|
/* FIXME */
|
|
|
|
|
break;
|
2012-02-22 15:26:34 +00:00
|
|
|
case BOOKE_INTERRUPT_PERFORMANCE_MONITOR:
|
|
|
|
|
kvmppc_fill_pt_regs(®s);
|
|
|
|
|
performance_monitor_exception(®s);
|
|
|
|
|
break;
|
2012-06-20 05:56:53 +00:00
|
|
|
case BOOKE_INTERRUPT_WATCHDOG:
|
|
|
|
|
kvmppc_fill_pt_regs(®s);
|
|
|
|
|
#ifdef CONFIG_BOOKE_WDT
|
|
|
|
|
WatchdogException(®s);
|
|
|
|
|
#else
|
|
|
|
|
unknown_exception(®s);
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
case BOOKE_INTERRUPT_CRITICAL:
|
|
|
|
|
unknown_exception(®s);
|
|
|
|
|
break;
|
2011-12-20 15:34:43 +00:00
|
|
|
}
|
2012-02-20 22:57:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* kvmppc_handle_exit
|
|
|
|
|
*
|
|
|
|
|
* Return value is in the form (errcode<<2 | RESUME_FLAG_HOST | RESUME_FLAG_NV)
|
|
|
|
|
*/
|
|
|
|
|
int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu,
|
|
|
|
|
unsigned int exit_nr)
|
|
|
|
|
{
|
|
|
|
|
int r = RESUME_HOST;
|
2012-08-13 10:44:41 +00:00
|
|
|
int s;
|
2012-02-20 22:57:26 +00:00
|
|
|
|
|
|
|
|
/* update before a new last_exit_type is rewritten */
|
|
|
|
|
kvmppc_update_timing_stats(vcpu);
|
|
|
|
|
|
|
|
|
|
/* restart interrupts if they were meant for the host */
|
|
|
|
|
kvmppc_restart_interrupt(vcpu, exit_nr);
|
2011-12-20 15:34:43 +00:00
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
local_irq_enable();
|
|
|
|
|
|
2012-08-02 13:10:00 +00:00
|
|
|
trace_kvm_exit(exit_nr, vcpu);
|
2012-08-12 09:29:09 +00:00
|
|
|
kvm_guest_exit();
|
2012-08-02 13:10:00 +00:00
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
run->exit_reason = KVM_EXIT_UNKNOWN;
|
|
|
|
|
run->ready_for_interrupt_injection = 1;
|
|
|
|
|
|
|
|
|
|
switch (exit_nr) {
|
|
|
|
|
case BOOKE_INTERRUPT_MACHINE_CHECK:
|
2012-02-20 11:21:18 +00:00
|
|
|
printk("MACHINE CHECK: %lx\n", mfspr(SPRN_MCSR));
|
|
|
|
|
kvmppc_dump_vcpu(vcpu);
|
|
|
|
|
/* For debugging, send invalid exit reason to user space */
|
|
|
|
|
run->hw.hardware_exit_reason = ~1ULL << 32;
|
|
|
|
|
run->hw.hardware_exit_reason |= mfspr(SPRN_MCSR);
|
|
|
|
|
r = RESUME_HOST;
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_EXTERNAL:
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, EXT_INTR_EXITS);
|
2008-11-05 15:36:21 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
case BOOKE_INTERRUPT_DECREMENTER:
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, DEC_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2012-06-20 05:56:53 +00:00
|
|
|
case BOOKE_INTERRUPT_WATCHDOG:
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
case BOOKE_INTERRUPT_DOORBELL:
|
|
|
|
|
kvmppc_account_exit(vcpu, DBELL_EXITS);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_GUEST_DBELL_CRIT:
|
|
|
|
|
kvmppc_account_exit(vcpu, GDBELL_EXITS);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We are here because there is a pending guest interrupt
|
|
|
|
|
* which could not be delivered as MSR_CE or MSR_ME was not
|
|
|
|
|
* set. Once we break from here we will retry delivery.
|
|
|
|
|
*/
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_GUEST_DBELL:
|
|
|
|
|
kvmppc_account_exit(vcpu, GDBELL_EXITS);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We are here because there is a pending guest interrupt
|
|
|
|
|
* which could not be delivered as MSR_EE was not set. Once
|
|
|
|
|
* we break from here we will retry delivery.
|
|
|
|
|
*/
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2012-02-20 21:45:12 +00:00
|
|
|
case BOOKE_INTERRUPT_PERFORMANCE_MONITOR:
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
case BOOKE_INTERRUPT_HV_PRIV:
|
|
|
|
|
r = emulation_exit(run, vcpu);
|
|
|
|
|
break;
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
case BOOKE_INTERRUPT_PROGRAM:
|
2011-12-20 15:34:43 +00:00
|
|
|
if (vcpu->arch.shared->msr & (MSR_PR | MSR_GS)) {
|
2012-02-20 11:33:22 +00:00
|
|
|
/*
|
|
|
|
|
* Program traps generated by user-level software must
|
|
|
|
|
* be handled by the guest kernel.
|
|
|
|
|
*
|
|
|
|
|
* In GS mode, hypervisor privileged instructions trap
|
|
|
|
|
* on BOOKE_INTERRUPT_HV_PRIV, not here, so these are
|
|
|
|
|
* actual program interrupts, handled by the guest.
|
|
|
|
|
*/
|
2010-02-02 11:44:35 +00:00
|
|
|
kvmppc_core_queue_program(vcpu, vcpu->arch.fault_esr);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, USR_PR_INST);
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
r = emulation_exit(run, vcpu);
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
|
2008-04-29 16:18:23 +00:00
|
|
|
case BOOKE_INTERRUPT_FP_UNAVAIL:
|
2008-11-05 15:36:23 +00:00
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_FP_UNAVAIL);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, FP_UNAVAIL);
|
2008-04-29 16:18:23 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2011-06-14 23:34:31 +00:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_UNAVAIL: {
|
|
|
|
|
if (vcpu->arch.shared->msr & MSR_SPE)
|
|
|
|
|
kvmppc_vcpu_enable_spe(vcpu);
|
|
|
|
|
else
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu,
|
|
|
|
|
BOOKE_IRQPRIO_SPE_UNAVAIL);
|
2009-01-03 22:23:13 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
2011-06-14 23:34:31 +00:00
|
|
|
}
|
2009-01-03 22:23:13 +00:00
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_FP_DATA:
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_SPE_FP_DATA);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_FP_ROUND:
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_SPE_FP_ROUND);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
2011-06-14 23:34:31 +00:00
|
|
|
#else
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_UNAVAIL:
|
|
|
|
|
/*
|
|
|
|
|
* Guest wants SPE, but host kernel doesn't support it. Send
|
|
|
|
|
* an "unimplemented operation" program check to the guest.
|
|
|
|
|
*/
|
|
|
|
|
kvmppc_core_queue_program(vcpu, ESR_PUO | ESR_SPV);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* These really should never happen without CONFIG_SPE,
|
|
|
|
|
* as we should never enable the real MSR[SPE] in the guest.
|
|
|
|
|
*/
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_FP_DATA:
|
|
|
|
|
case BOOKE_INTERRUPT_SPE_FP_ROUND:
|
|
|
|
|
printk(KERN_CRIT "%s: unexpected SPE interrupt %u at %08lx\n",
|
|
|
|
|
__func__, exit_nr, vcpu->arch.pc);
|
|
|
|
|
run->hw.hardware_exit_reason = exit_nr;
|
|
|
|
|
r = RESUME_HOST;
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
2009-01-03 22:23:13 +00:00
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
case BOOKE_INTERRUPT_DATA_STORAGE:
|
2010-02-02 11:44:35 +00:00
|
|
|
kvmppc_core_queue_data_storage(vcpu, vcpu->arch.fault_dear,
|
|
|
|
|
vcpu->arch.fault_esr);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, DSI_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_INST_STORAGE:
|
2010-02-02 11:44:35 +00:00
|
|
|
kvmppc_core_queue_inst_storage(vcpu, vcpu->arch.fault_esr);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, ISI_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2013-01-31 13:17:38 +00:00
|
|
|
case BOOKE_INTERRUPT_ALIGNMENT:
|
|
|
|
|
kvmppc_core_queue_alignment(vcpu, vcpu->arch.fault_dear,
|
|
|
|
|
vcpu->arch.fault_esr);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
case BOOKE_INTERRUPT_HV_SYSCALL:
|
|
|
|
|
if (!(vcpu->arch.shared->msr & MSR_PR)) {
|
|
|
|
|
kvmppc_set_gpr(vcpu, 3, kvmppc_kvm_pv(vcpu));
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* hcall from guest userspace -- send privileged
|
|
|
|
|
* instruction program check.
|
|
|
|
|
*/
|
|
|
|
|
kvmppc_core_queue_program(vcpu, ESR_PPR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
#else
|
2008-04-17 04:28:09 +00:00
|
|
|
case BOOKE_INTERRUPT_SYSCALL:
|
2010-07-29 12:47:48 +00:00
|
|
|
if (!(vcpu->arch.shared->msr & MSR_PR) &&
|
|
|
|
|
(((u32)kvmppc_get_gpr(vcpu, 0)) == KVM_SC_MAGIC_R0)) {
|
|
|
|
|
/* KVM PV hypercalls */
|
|
|
|
|
kvmppc_set_gpr(vcpu, 3, kvmppc_kvm_pv(vcpu));
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
} else {
|
|
|
|
|
/* Guest syscalls */
|
|
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_SYSCALL);
|
|
|
|
|
}
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, SYSCALL_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
2011-12-20 15:34:43 +00:00
|
|
|
#endif
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_DTLB_MISS: {
|
|
|
|
|
unsigned long eaddr = vcpu->arch.fault_dear;
|
2008-12-02 21:51:55 +00:00
|
|
|
int gtlb_index;
|
2009-01-03 22:23:00 +00:00
|
|
|
gpa_t gpaddr;
|
2008-04-17 04:28:09 +00:00
|
|
|
gfn_t gfn;
|
|
|
|
|
|
2012-02-15 23:40:00 +00:00
|
|
|
#ifdef CONFIG_KVM_E500V2
|
2011-06-14 23:34:41 +00:00
|
|
|
if (!(vcpu->arch.shared->msr & MSR_PR) &&
|
|
|
|
|
(eaddr & PAGE_MASK) == vcpu->arch.magic_page_ea) {
|
|
|
|
|
kvmppc_map_magic(vcpu);
|
|
|
|
|
kvmppc_account_exit(vcpu, DTLB_VIRT_MISS_EXITS);
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
/* Check the guest TLB. */
|
2009-01-03 22:23:03 +00:00
|
|
|
gtlb_index = kvmppc_mmu_dtlb_index(vcpu, eaddr);
|
2008-12-02 21:51:55 +00:00
|
|
|
if (gtlb_index < 0) {
|
2008-04-17 04:28:09 +00:00
|
|
|
/* The guest didn't have a mapping for it. */
|
2010-02-02 11:44:35 +00:00
|
|
|
kvmppc_core_queue_dtlb_miss(vcpu,
|
|
|
|
|
vcpu->arch.fault_dear,
|
|
|
|
|
vcpu->arch.fault_esr);
|
2009-01-03 22:23:11 +00:00
|
|
|
kvmppc_mmu_dtlb_miss(vcpu);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, DTLB_REAL_MISS_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-03 22:23:02 +00:00
|
|
|
gpaddr = kvmppc_mmu_xlate(vcpu, gtlb_index, eaddr);
|
2009-01-03 22:23:00 +00:00
|
|
|
gfn = gpaddr >> PAGE_SHIFT;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
if (kvm_is_visible_gfn(vcpu->kvm, gfn)) {
|
|
|
|
|
/* The guest TLB had a mapping, but the shadow TLB
|
|
|
|
|
* didn't, and it is RAM. This could be because:
|
|
|
|
|
* a) the entry is mapping the host kernel, or
|
|
|
|
|
* b) the guest used a large mapping which we're faking
|
|
|
|
|
* Either way, we need to satisfy the fault without
|
|
|
|
|
* invoking the guest. */
|
2009-01-03 22:23:01 +00:00
|
|
|
kvmppc_mmu_map(vcpu, eaddr, gpaddr, gtlb_index);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, DTLB_VIRT_MISS_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
} else {
|
|
|
|
|
/* Guest has mapped and accessed a page which is not
|
|
|
|
|
* actually RAM. */
|
2009-01-03 22:23:00 +00:00
|
|
|
vcpu->arch.paddr_accessed = gpaddr;
|
2012-03-12 01:26:30 +00:00
|
|
|
vcpu->arch.vaddr_accessed = eaddr;
|
2008-04-17 04:28:09 +00:00
|
|
|
r = kvmppc_emulate_mmio(run, vcpu);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, MMIO_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case BOOKE_INTERRUPT_ITLB_MISS: {
|
|
|
|
|
unsigned long eaddr = vcpu->arch.pc;
|
2008-12-02 21:51:53 +00:00
|
|
|
gpa_t gpaddr;
|
2008-04-17 04:28:09 +00:00
|
|
|
gfn_t gfn;
|
2008-12-02 21:51:55 +00:00
|
|
|
int gtlb_index;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
r = RESUME_GUEST;
|
|
|
|
|
|
|
|
|
|
/* Check the guest TLB. */
|
2009-01-03 22:23:03 +00:00
|
|
|
gtlb_index = kvmppc_mmu_itlb_index(vcpu, eaddr);
|
2008-12-02 21:51:55 +00:00
|
|
|
if (gtlb_index < 0) {
|
2008-04-17 04:28:09 +00:00
|
|
|
/* The guest didn't have a mapping for it. */
|
2008-11-05 15:36:23 +00:00
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_ITLB_MISS);
|
2009-01-03 22:23:11 +00:00
|
|
|
kvmppc_mmu_itlb_miss(vcpu);
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, ITLB_REAL_MISS_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, ITLB_VIRT_MISS_EXITS);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2009-01-03 22:23:02 +00:00
|
|
|
gpaddr = kvmppc_mmu_xlate(vcpu, gtlb_index, eaddr);
|
2008-12-02 21:51:53 +00:00
|
|
|
gfn = gpaddr >> PAGE_SHIFT;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
if (kvm_is_visible_gfn(vcpu->kvm, gfn)) {
|
|
|
|
|
/* The guest TLB had a mapping, but the shadow TLB
|
|
|
|
|
* didn't. This could be because:
|
|
|
|
|
* a) the entry is mapping the host kernel, or
|
|
|
|
|
* b) the guest used a large mapping which we're faking
|
|
|
|
|
* Either way, we need to satisfy the fault without
|
|
|
|
|
* invoking the guest. */
|
2009-01-03 22:23:01 +00:00
|
|
|
kvmppc_mmu_map(vcpu, eaddr, gpaddr, gtlb_index);
|
2008-04-17 04:28:09 +00:00
|
|
|
} else {
|
|
|
|
|
/* Guest mapped and leaped at non-RAM! */
|
2008-11-05 15:36:23 +00:00
|
|
|
kvmppc_booke_queue_irqprio(vcpu, BOOKE_IRQPRIO_MACHINE_CHECK);
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-07-25 18:54:49 +00:00
|
|
|
case BOOKE_INTERRUPT_DEBUG: {
|
|
|
|
|
u32 dbsr;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.pc = mfspr(SPRN_CSRR0);
|
|
|
|
|
|
|
|
|
|
/* clear IAC events in DBSR register */
|
|
|
|
|
dbsr = mfspr(SPRN_DBSR);
|
|
|
|
|
dbsr &= DBSR_IAC1 | DBSR_IAC2 | DBSR_IAC3 | DBSR_IAC4;
|
|
|
|
|
mtspr(SPRN_DBSR, dbsr);
|
|
|
|
|
|
|
|
|
|
run->exit_reason = KVM_EXIT_DEBUG;
|
2008-12-02 21:51:58 +00:00
|
|
|
kvmppc_account_exit(vcpu, DEBUG_EXITS);
|
2008-07-25 18:54:49 +00:00
|
|
|
r = RESUME_HOST;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
default:
|
|
|
|
|
printk(KERN_EMERG "exit_nr %d\n", exit_nr);
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-16 14:07:37 +00:00
|
|
|
/*
|
|
|
|
|
* To avoid clobbering exit_reason, only check for signals if we
|
|
|
|
|
* aren't already exiting to userspace for some other reason.
|
|
|
|
|
*/
|
2012-02-28 11:00:41 +00:00
|
|
|
if (!(r & RESUME_HOST)) {
|
|
|
|
|
local_irq_disable();
|
2012-08-13 10:44:41 +00:00
|
|
|
s = kvmppc_prepare_to_enter(vcpu);
|
|
|
|
|
if (s <= 0) {
|
2012-08-12 10:42:30 +00:00
|
|
|
local_irq_enable();
|
2012-08-13 10:44:41 +00:00
|
|
|
r = (s << 2) | RESUME_HOST | (r & RESUME_FLAG_NV);
|
2012-08-12 10:42:30 +00:00
|
|
|
} else {
|
2012-08-12 23:04:19 +00:00
|
|
|
kvmppc_lazy_ee_enable();
|
2012-02-28 11:00:41 +00:00
|
|
|
}
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-24 18:57:11 +00:00
|
|
|
static void kvmppc_set_tsr(struct kvm_vcpu *vcpu, u32 new_tsr)
|
|
|
|
|
{
|
|
|
|
|
u32 old_tsr = vcpu->arch.tsr;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.tsr = new_tsr;
|
|
|
|
|
|
|
|
|
|
if ((old_tsr ^ vcpu->arch.tsr) & (TSR_ENW | TSR_WIS))
|
|
|
|
|
arm_next_watchdog(vcpu);
|
|
|
|
|
|
|
|
|
|
update_timer_ints(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
/* Initial guest state: 16MB mapping 0 -> 0, PC = 0, MSR = 0, R1 = 16MB */
|
|
|
|
|
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2010-08-07 17:33:56 +00:00
|
|
|
int i;
|
2011-08-10 11:57:08 +00:00
|
|
|
int r;
|
2010-08-07 17:33:56 +00:00
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
vcpu->arch.pc = 0;
|
KVM: PPC: Paravirtualize SPRG4-7, ESR, PIR, MASn
This allows additional registers to be accessed by the guest
in PR-mode KVM without trapping.
SPRG4-7 are readable from userspace. On booke, KVM will sync
these registers when it enters the guest, so that accesses from
guest userspace will work. The guest kernel, OTOH, must consistently
use either the real registers or the shared area between exits. This
also applies to the already-paravirted SPRG3.
On non-booke, it's not clear to what extent SPRG4-7 are supported
(they're not architected for book3s, but exist on at least some classic
chips). They are copied in the get/set regs ioctls, but I do not see any
non-booke emulation. I also do not see any syncing with real registers
(in PR-mode) including the user-readable SPRG3. This patch should not
make that situation any worse.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-11-09 00:23:30 +00:00
|
|
|
vcpu->arch.shared->pir = vcpu->vcpu_id;
|
2010-01-08 01:58:01 +00:00
|
|
|
kvmppc_set_gpr(vcpu, 1, (16<<20) - 8); /* -8 for the callee-save LR slot */
|
2011-12-20 15:34:43 +00:00
|
|
|
kvmppc_set_msr(vcpu, 0);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2011-12-20 15:34:43 +00:00
|
|
|
#ifndef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
vcpu->arch.shadow_msr = MSR_USER | MSR_DE | MSR_IS | MSR_DS;
|
2008-07-25 18:54:53 +00:00
|
|
|
vcpu->arch.shadow_pid = 1;
|
2011-12-20 15:34:43 +00:00
|
|
|
vcpu->arch.shared->msr = 0;
|
|
|
|
|
#endif
|
2008-07-25 18:54:53 +00:00
|
|
|
|
2010-08-07 17:33:56 +00:00
|
|
|
/* Eye-catching numbers so we know if the guest takes an interrupt
|
|
|
|
|
* before it's programmed its own IVPR/IVORs. */
|
2008-04-17 04:28:09 +00:00
|
|
|
vcpu->arch.ivpr = 0x55550000;
|
2010-08-07 17:33:56 +00:00
|
|
|
for (i = 0; i < BOOKE_IRQPRIO_MAX; i++)
|
|
|
|
|
vcpu->arch.ivor[i] = 0x7700 | i * 4;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2008-12-02 21:51:57 +00:00
|
|
|
kvmppc_init_timing_stats(vcpu);
|
|
|
|
|
|
2011-08-10 11:57:08 +00:00
|
|
|
r = kvmppc_core_vcpu_setup(vcpu);
|
|
|
|
|
kvmppc_sanity_check(vcpu);
|
|
|
|
|
return r;
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-08 20:38:19 +00:00
|
|
|
int kvmppc_subarch_vcpu_init(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
/* setup watchdog timer once */
|
|
|
|
|
spin_lock_init(&vcpu->arch.wdt_lock);
|
|
|
|
|
setup_timer(&vcpu->arch.wdt_timer, kvmppc_watchdog_func,
|
|
|
|
|
(unsigned long)vcpu);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
del_timer_sync(&vcpu->arch.wdt_timer);
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
regs->pc = vcpu->arch.pc;
|
2010-01-08 01:58:02 +00:00
|
|
|
regs->cr = kvmppc_get_cr(vcpu);
|
2008-04-17 04:28:09 +00:00
|
|
|
regs->ctr = vcpu->arch.ctr;
|
|
|
|
|
regs->lr = vcpu->arch.lr;
|
2010-01-08 01:58:02 +00:00
|
|
|
regs->xer = kvmppc_get_xer(vcpu);
|
2010-07-29 12:47:43 +00:00
|
|
|
regs->msr = vcpu->arch.shared->msr;
|
2010-07-29 12:47:46 +00:00
|
|
|
regs->srr0 = vcpu->arch.shared->srr0;
|
|
|
|
|
regs->srr1 = vcpu->arch.shared->srr1;
|
2008-04-17 04:28:09 +00:00
|
|
|
regs->pid = vcpu->arch.pid;
|
2010-07-29 12:47:47 +00:00
|
|
|
regs->sprg0 = vcpu->arch.shared->sprg0;
|
|
|
|
|
regs->sprg1 = vcpu->arch.shared->sprg1;
|
|
|
|
|
regs->sprg2 = vcpu->arch.shared->sprg2;
|
|
|
|
|
regs->sprg3 = vcpu->arch.shared->sprg3;
|
KVM: PPC: Paravirtualize SPRG4-7, ESR, PIR, MASn
This allows additional registers to be accessed by the guest
in PR-mode KVM without trapping.
SPRG4-7 are readable from userspace. On booke, KVM will sync
these registers when it enters the guest, so that accesses from
guest userspace will work. The guest kernel, OTOH, must consistently
use either the real registers or the shared area between exits. This
also applies to the already-paravirted SPRG3.
On non-booke, it's not clear to what extent SPRG4-7 are supported
(they're not architected for book3s, but exist on at least some classic
chips). They are copied in the get/set regs ioctls, but I do not see any
non-booke emulation. I also do not see any syncing with real registers
(in PR-mode) including the user-readable SPRG3. This patch should not
make that situation any worse.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-11-09 00:23:30 +00:00
|
|
|
regs->sprg4 = vcpu->arch.shared->sprg4;
|
|
|
|
|
regs->sprg5 = vcpu->arch.shared->sprg5;
|
|
|
|
|
regs->sprg6 = vcpu->arch.shared->sprg6;
|
|
|
|
|
regs->sprg7 = vcpu->arch.shared->sprg7;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
|
2010-01-08 01:58:01 +00:00
|
|
|
regs->gpr[i] = kvmppc_get_gpr(vcpu, i);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.pc = regs->pc;
|
2010-01-08 01:58:02 +00:00
|
|
|
kvmppc_set_cr(vcpu, regs->cr);
|
2008-04-17 04:28:09 +00:00
|
|
|
vcpu->arch.ctr = regs->ctr;
|
|
|
|
|
vcpu->arch.lr = regs->lr;
|
2010-01-08 01:58:02 +00:00
|
|
|
kvmppc_set_xer(vcpu, regs->xer);
|
2008-11-05 15:36:20 +00:00
|
|
|
kvmppc_set_msr(vcpu, regs->msr);
|
2010-07-29 12:47:46 +00:00
|
|
|
vcpu->arch.shared->srr0 = regs->srr0;
|
|
|
|
|
vcpu->arch.shared->srr1 = regs->srr1;
|
2011-04-27 22:24:21 +00:00
|
|
|
kvmppc_set_pid(vcpu, regs->pid);
|
2010-07-29 12:47:47 +00:00
|
|
|
vcpu->arch.shared->sprg0 = regs->sprg0;
|
|
|
|
|
vcpu->arch.shared->sprg1 = regs->sprg1;
|
|
|
|
|
vcpu->arch.shared->sprg2 = regs->sprg2;
|
|
|
|
|
vcpu->arch.shared->sprg3 = regs->sprg3;
|
KVM: PPC: Paravirtualize SPRG4-7, ESR, PIR, MASn
This allows additional registers to be accessed by the guest
in PR-mode KVM without trapping.
SPRG4-7 are readable from userspace. On booke, KVM will sync
these registers when it enters the guest, so that accesses from
guest userspace will work. The guest kernel, OTOH, must consistently
use either the real registers or the shared area between exits. This
also applies to the already-paravirted SPRG3.
On non-booke, it's not clear to what extent SPRG4-7 are supported
(they're not architected for book3s, but exist on at least some classic
chips). They are copied in the get/set regs ioctls, but I do not see any
non-booke emulation. I also do not see any syncing with real registers
(in PR-mode) including the user-readable SPRG3. This patch should not
make that situation any worse.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-11-09 00:23:30 +00:00
|
|
|
vcpu->arch.shared->sprg4 = regs->sprg4;
|
|
|
|
|
vcpu->arch.shared->sprg5 = regs->sprg5;
|
|
|
|
|
vcpu->arch.shared->sprg6 = regs->sprg6;
|
|
|
|
|
vcpu->arch.shared->sprg7 = regs->sprg7;
|
2008-04-17 04:28:09 +00:00
|
|
|
|
2010-01-08 01:58:01 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
|
|
|
|
|
kvmppc_set_gpr(vcpu, i, regs->gpr[i]);
|
2008-04-17 04:28:09 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-27 22:24:21 +00:00
|
|
|
static void get_sregs_base(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
u64 tb = get_tb();
|
|
|
|
|
|
|
|
|
|
sregs->u.e.features |= KVM_SREGS_E_BASE;
|
|
|
|
|
|
|
|
|
|
sregs->u.e.csrr0 = vcpu->arch.csrr0;
|
|
|
|
|
sregs->u.e.csrr1 = vcpu->arch.csrr1;
|
|
|
|
|
sregs->u.e.mcsr = vcpu->arch.mcsr;
|
2011-12-20 15:34:43 +00:00
|
|
|
sregs->u.e.esr = get_guest_esr(vcpu);
|
|
|
|
|
sregs->u.e.dear = get_guest_dear(vcpu);
|
2011-04-27 22:24:21 +00:00
|
|
|
sregs->u.e.tsr = vcpu->arch.tsr;
|
|
|
|
|
sregs->u.e.tcr = vcpu->arch.tcr;
|
|
|
|
|
sregs->u.e.dec = kvmppc_get_dec(vcpu, tb);
|
|
|
|
|
sregs->u.e.tb = tb;
|
|
|
|
|
sregs->u.e.vrsave = vcpu->arch.vrsave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int set_sregs_base(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
if (!(sregs->u.e.features & KVM_SREGS_E_BASE))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.csrr0 = sregs->u.e.csrr0;
|
|
|
|
|
vcpu->arch.csrr1 = sregs->u.e.csrr1;
|
|
|
|
|
vcpu->arch.mcsr = sregs->u.e.mcsr;
|
2011-12-20 15:34:43 +00:00
|
|
|
set_guest_esr(vcpu, sregs->u.e.esr);
|
|
|
|
|
set_guest_dear(vcpu, sregs->u.e.dear);
|
2011-04-27 22:24:21 +00:00
|
|
|
vcpu->arch.vrsave = sregs->u.e.vrsave;
|
2011-11-17 12:39:59 +00:00
|
|
|
kvmppc_set_tcr(vcpu, sregs->u.e.tcr);
|
2011-04-27 22:24:21 +00:00
|
|
|
|
2011-11-17 12:39:59 +00:00
|
|
|
if (sregs->u.e.update_special & KVM_SREGS_E_UPDATE_DEC) {
|
2011-04-27 22:24:21 +00:00
|
|
|
vcpu->arch.dec = sregs->u.e.dec;
|
2011-11-17 12:39:59 +00:00
|
|
|
kvmppc_emulate_dec(vcpu);
|
|
|
|
|
}
|
2011-04-27 22:24:21 +00:00
|
|
|
|
2013-02-24 18:57:11 +00:00
|
|
|
if (sregs->u.e.update_special & KVM_SREGS_E_UPDATE_TSR)
|
|
|
|
|
kvmppc_set_tsr(vcpu, sregs->u.e.tsr);
|
2011-04-27 22:24:21 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void get_sregs_arch206(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
sregs->u.e.features |= KVM_SREGS_E_ARCH206;
|
|
|
|
|
|
2011-09-02 22:39:37 +00:00
|
|
|
sregs->u.e.pir = vcpu->vcpu_id;
|
2011-04-27 22:24:21 +00:00
|
|
|
sregs->u.e.mcsrr0 = vcpu->arch.mcsrr0;
|
|
|
|
|
sregs->u.e.mcsrr1 = vcpu->arch.mcsrr1;
|
|
|
|
|
sregs->u.e.decar = vcpu->arch.decar;
|
|
|
|
|
sregs->u.e.ivpr = vcpu->arch.ivpr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int set_sregs_arch206(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
if (!(sregs->u.e.features & KVM_SREGS_E_ARCH206))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2011-09-02 22:39:37 +00:00
|
|
|
if (sregs->u.e.pir != vcpu->vcpu_id)
|
2011-04-27 22:24:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.mcsrr0 = sregs->u.e.mcsrr0;
|
|
|
|
|
vcpu->arch.mcsrr1 = sregs->u.e.mcsrr1;
|
|
|
|
|
vcpu->arch.decar = sregs->u.e.decar;
|
|
|
|
|
vcpu->arch.ivpr = sregs->u.e.ivpr;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
sregs->u.e.features |= KVM_SREGS_E_IVOR;
|
|
|
|
|
|
|
|
|
|
sregs->u.e.ivor_low[0] = vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL];
|
|
|
|
|
sregs->u.e.ivor_low[1] = vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK];
|
|
|
|
|
sregs->u.e.ivor_low[2] = vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE];
|
|
|
|
|
sregs->u.e.ivor_low[3] = vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE];
|
|
|
|
|
sregs->u.e.ivor_low[4] = vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL];
|
|
|
|
|
sregs->u.e.ivor_low[5] = vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT];
|
|
|
|
|
sregs->u.e.ivor_low[6] = vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM];
|
|
|
|
|
sregs->u.e.ivor_low[7] = vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL];
|
|
|
|
|
sregs->u.e.ivor_low[8] = vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL];
|
|
|
|
|
sregs->u.e.ivor_low[9] = vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL];
|
|
|
|
|
sregs->u.e.ivor_low[10] = vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER];
|
|
|
|
|
sregs->u.e.ivor_low[11] = vcpu->arch.ivor[BOOKE_IRQPRIO_FIT];
|
|
|
|
|
sregs->u.e.ivor_low[12] = vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG];
|
|
|
|
|
sregs->u.e.ivor_low[13] = vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS];
|
|
|
|
|
sregs->u.e.ivor_low[14] = vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS];
|
|
|
|
|
sregs->u.e.ivor_low[15] = vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvmppc_set_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
|
|
|
|
|
{
|
|
|
|
|
if (!(sregs->u.e.features & KVM_SREGS_E_IVOR))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL] = sregs->u.e.ivor_low[0];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK] = sregs->u.e.ivor_low[1];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE] = sregs->u.e.ivor_low[2];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE] = sregs->u.e.ivor_low[3];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL] = sregs->u.e.ivor_low[4];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT] = sregs->u.e.ivor_low[5];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM] = sregs->u.e.ivor_low[6];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL] = sregs->u.e.ivor_low[7];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL] = sregs->u.e.ivor_low[8];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL] = sregs->u.e.ivor_low[9];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER] = sregs->u.e.ivor_low[10];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_FIT] = sregs->u.e.ivor_low[11];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG] = sregs->u.e.ivor_low[12];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS] = sregs->u.e.ivor_low[13];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS] = sregs->u.e.ivor_low[14];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG] = sregs->u.e.ivor_low[15];
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
2011-04-27 22:24:21 +00:00
|
|
|
sregs->pvr = vcpu->arch.pvr;
|
|
|
|
|
|
|
|
|
|
get_sregs_base(vcpu, sregs);
|
|
|
|
|
get_sregs_arch206(vcpu, sregs);
|
|
|
|
|
kvmppc_core_get_sregs(vcpu, sregs);
|
|
|
|
|
return 0;
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
2011-04-27 22:24:21 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (vcpu->arch.pvr != sregs->pvr)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
ret = set_sregs_base(vcpu, sregs);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = set_sregs_arch206(vcpu, sregs);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
return kvmppc_core_set_sregs(vcpu, sregs);
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
|
|
|
|
|
2011-12-12 12:26:50 +00:00
|
|
|
int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
|
|
|
|
|
{
|
2012-08-08 21:17:55 +00:00
|
|
|
int r = -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (reg->id) {
|
|
|
|
|
case KVM_REG_PPC_IAC1:
|
|
|
|
|
case KVM_REG_PPC_IAC2:
|
|
|
|
|
case KVM_REG_PPC_IAC3:
|
|
|
|
|
case KVM_REG_PPC_IAC4: {
|
|
|
|
|
int iac = reg->id - KVM_REG_PPC_IAC1;
|
|
|
|
|
r = copy_to_user((u64 __user *)(long)reg->addr,
|
|
|
|
|
&vcpu->arch.dbg_reg.iac[iac], sizeof(u64));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_REG_PPC_DAC1:
|
|
|
|
|
case KVM_REG_PPC_DAC2: {
|
|
|
|
|
int dac = reg->id - KVM_REG_PPC_DAC1;
|
|
|
|
|
r = copy_to_user((u64 __user *)(long)reg->addr,
|
|
|
|
|
&vcpu->arch.dbg_reg.dac[dac], sizeof(u64));
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-01-04 17:28:51 +00:00
|
|
|
case KVM_REG_PPC_EPR: {
|
|
|
|
|
u32 epr = get_guest_epr(vcpu);
|
|
|
|
|
r = put_user(epr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-10-11 06:13:29 +00:00
|
|
|
#if defined(CONFIG_64BIT)
|
|
|
|
|
case KVM_REG_PPC_EPCR:
|
|
|
|
|
r = put_user(vcpu->arch.epcr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
2013-02-24 18:57:12 +00:00
|
|
|
case KVM_REG_PPC_TCR:
|
|
|
|
|
r = put_user(vcpu->arch.tcr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_PPC_TSR:
|
|
|
|
|
r = put_user(vcpu->arch.tsr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
break;
|
2012-08-08 21:17:55 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return r;
|
2011-12-12 12:26:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
|
|
|
|
|
{
|
2012-08-08 21:17:55 +00:00
|
|
|
int r = -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (reg->id) {
|
|
|
|
|
case KVM_REG_PPC_IAC1:
|
|
|
|
|
case KVM_REG_PPC_IAC2:
|
|
|
|
|
case KVM_REG_PPC_IAC3:
|
|
|
|
|
case KVM_REG_PPC_IAC4: {
|
|
|
|
|
int iac = reg->id - KVM_REG_PPC_IAC1;
|
|
|
|
|
r = copy_from_user(&vcpu->arch.dbg_reg.iac[iac],
|
|
|
|
|
(u64 __user *)(long)reg->addr, sizeof(u64));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_REG_PPC_DAC1:
|
|
|
|
|
case KVM_REG_PPC_DAC2: {
|
|
|
|
|
int dac = reg->id - KVM_REG_PPC_DAC1;
|
|
|
|
|
r = copy_from_user(&vcpu->arch.dbg_reg.dac[dac],
|
|
|
|
|
(u64 __user *)(long)reg->addr, sizeof(u64));
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-01-04 17:28:51 +00:00
|
|
|
case KVM_REG_PPC_EPR: {
|
|
|
|
|
u32 new_epr;
|
|
|
|
|
r = get_user(new_epr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
if (!r)
|
|
|
|
|
kvmppc_set_epr(vcpu, new_epr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-10-11 06:13:29 +00:00
|
|
|
#if defined(CONFIG_64BIT)
|
|
|
|
|
case KVM_REG_PPC_EPCR: {
|
|
|
|
|
u32 new_epcr;
|
|
|
|
|
r = get_user(new_epcr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
if (r == 0)
|
|
|
|
|
kvmppc_set_epcr(vcpu, new_epcr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2013-02-24 18:57:12 +00:00
|
|
|
case KVM_REG_PPC_OR_TSR: {
|
|
|
|
|
u32 tsr_bits;
|
|
|
|
|
r = get_user(tsr_bits, (u32 __user *)(long)reg->addr);
|
|
|
|
|
kvmppc_set_tsr_bits(vcpu, tsr_bits);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_REG_PPC_CLEAR_TSR: {
|
|
|
|
|
u32 tsr_bits;
|
|
|
|
|
r = get_user(tsr_bits, (u32 __user *)(long)reg->addr);
|
|
|
|
|
kvmppc_clr_tsr_bits(vcpu, tsr_bits);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_REG_PPC_TSR: {
|
|
|
|
|
u32 tsr;
|
|
|
|
|
r = get_user(tsr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
kvmppc_set_tsr(vcpu, tsr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_REG_PPC_TCR: {
|
|
|
|
|
u32 tcr;
|
|
|
|
|
r = get_user(tcr, (u32 __user *)(long)reg->addr);
|
|
|
|
|
kvmppc_set_tcr(vcpu, tcr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-08-08 21:17:55 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return r;
|
2011-12-12 12:26:50 +00:00
|
|
|
}
|
|
|
|
|
|
2008-04-17 04:28:09 +00:00
|
|
|
int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
|
|
|
|
|
{
|
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
|
|
|
|
|
{
|
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_translation *tr)
|
|
|
|
|
{
|
2010-05-13 08:05:49 +00:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
r = kvmppc_core_vcpu_translate(vcpu, tr);
|
|
|
|
|
return r;
|
2008-04-17 04:28:09 +00:00
|
|
|
}
|
2008-11-05 15:36:13 +00:00
|
|
|
|
2009-10-30 05:47:01 +00:00
|
|
|
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
|
|
|
|
|
{
|
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-11 13:27:46 +00:00
|
|
|
void kvmppc_core_free_memslot(struct kvm_memory_slot *free,
|
|
|
|
|
struct kvm_memory_slot *dont)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvmppc_core_create_memslot(struct kvm_memory_slot *slot,
|
|
|
|
|
unsigned long npages)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-29 00:19:22 +00:00
|
|
|
int kvmppc_core_prepare_memory_region(struct kvm *kvm,
|
2012-09-11 13:27:46 +00:00
|
|
|
struct kvm_memory_slot *memslot,
|
2011-06-29 00:19:22 +00:00
|
|
|
struct kvm_userspace_memory_region *mem)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_core_commit_memory_region(struct kvm *kvm,
|
2012-09-11 13:28:18 +00:00
|
|
|
struct kvm_userspace_memory_region *mem,
|
2013-02-27 10:45:25 +00:00
|
|
|
const struct kvm_memory_slot *old)
|
2012-09-11 13:28:18 +00:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot)
|
2011-06-29 00:19:22 +00:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-11 06:13:27 +00:00
|
|
|
void kvmppc_set_epcr(struct kvm_vcpu *vcpu, u32 new_epcr)
|
|
|
|
|
{
|
|
|
|
|
#if defined(CONFIG_64BIT)
|
|
|
|
|
vcpu->arch.epcr = new_epcr;
|
|
|
|
|
#ifdef CONFIG_KVM_BOOKE_HV
|
|
|
|
|
vcpu->arch.shadow_epcr &= ~SPRN_EPCR_GICM;
|
|
|
|
|
if (vcpu->arch.epcr & SPRN_EPCR_ICM)
|
|
|
|
|
vcpu->arch.shadow_epcr |= SPRN_EPCR_GICM;
|
|
|
|
|
#endif
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-17 12:39:59 +00:00
|
|
|
void kvmppc_set_tcr(struct kvm_vcpu *vcpu, u32 new_tcr)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.tcr = new_tcr;
|
2012-08-08 20:38:19 +00:00
|
|
|
arm_next_watchdog(vcpu);
|
2011-11-17 12:39:59 +00:00
|
|
|
update_timer_ints(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_set_tsr_bits(struct kvm_vcpu *vcpu, u32 tsr_bits)
|
|
|
|
|
{
|
|
|
|
|
set_bits(tsr_bits, &vcpu->arch.tsr);
|
|
|
|
|
smp_wmb();
|
|
|
|
|
kvm_make_request(KVM_REQ_PENDING_TIMER, vcpu);
|
|
|
|
|
kvm_vcpu_kick(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_clr_tsr_bits(struct kvm_vcpu *vcpu, u32 tsr_bits)
|
|
|
|
|
{
|
|
|
|
|
clear_bits(tsr_bits, &vcpu->arch.tsr);
|
2012-08-08 20:38:19 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We may have stopped the watchdog due to
|
|
|
|
|
* being stuck on final expiration.
|
|
|
|
|
*/
|
|
|
|
|
if (tsr_bits & (TSR_ENW | TSR_WIS))
|
|
|
|
|
arm_next_watchdog(vcpu);
|
|
|
|
|
|
2011-11-17 12:39:59 +00:00
|
|
|
update_timer_ints(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_decrementer_func(unsigned long data)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
|
|
|
|
|
|
2012-05-20 23:21:23 +00:00
|
|
|
if (vcpu->arch.tcr & TCR_ARE) {
|
|
|
|
|
vcpu->arch.dec = vcpu->arch.decar;
|
|
|
|
|
kvmppc_emulate_dec(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-17 12:39:59 +00:00
|
|
|
kvmppc_set_tsr_bits(vcpu, TSR_DIS);
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 15:34:22 +00:00
|
|
|
void kvmppc_booke_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
|
|
|
|
|
{
|
2012-09-20 19:35:51 +00:00
|
|
|
vcpu->cpu = smp_processor_id();
|
2011-12-20 15:34:43 +00:00
|
|
|
current->thread.kvm_vcpu = vcpu;
|
2011-12-20 15:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_booke_vcpu_put(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2011-12-20 15:34:43 +00:00
|
|
|
current->thread.kvm_vcpu = NULL;
|
2012-09-20 19:35:51 +00:00
|
|
|
vcpu->cpu = -1;
|
2011-12-20 15:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
2009-06-02 01:46:14 +00:00
|
|
|
int __init kvmppc_booke_init(void)
|
2008-11-05 15:36:13 +00:00
|
|
|
{
|
2011-12-20 15:34:43 +00:00
|
|
|
#ifndef CONFIG_KVM_BOOKE_HV
|
2008-11-05 15:36:13 +00:00
|
|
|
unsigned long ivor[16];
|
2013-01-15 22:24:39 +00:00
|
|
|
unsigned long *handler = kvmppc_booke_handler_addr;
|
2008-11-05 15:36:13 +00:00
|
|
|
unsigned long max_ivor = 0;
|
2013-01-15 22:24:39 +00:00
|
|
|
unsigned long handler_len;
|
2008-11-05 15:36:13 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* We install our own exception handlers by hijacking IVPR. IVPR must
|
|
|
|
|
* be 16-bit aligned, so we need a 64KB allocation. */
|
|
|
|
|
kvmppc_booke_handlers = __get_free_pages(GFP_KERNEL | __GFP_ZERO,
|
|
|
|
|
VCPU_SIZE_ORDER);
|
|
|
|
|
if (!kvmppc_booke_handlers)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
/* XXX make sure our handlers are smaller than Linux's */
|
|
|
|
|
|
|
|
|
|
/* Copy our interrupt handlers to match host IVORs. That way we don't
|
|
|
|
|
* have to swap the IVORs on every guest/host transition. */
|
|
|
|
|
ivor[0] = mfspr(SPRN_IVOR0);
|
|
|
|
|
ivor[1] = mfspr(SPRN_IVOR1);
|
|
|
|
|
ivor[2] = mfspr(SPRN_IVOR2);
|
|
|
|
|
ivor[3] = mfspr(SPRN_IVOR3);
|
|
|
|
|
ivor[4] = mfspr(SPRN_IVOR4);
|
|
|
|
|
ivor[5] = mfspr(SPRN_IVOR5);
|
|
|
|
|
ivor[6] = mfspr(SPRN_IVOR6);
|
|
|
|
|
ivor[7] = mfspr(SPRN_IVOR7);
|
|
|
|
|
ivor[8] = mfspr(SPRN_IVOR8);
|
|
|
|
|
ivor[9] = mfspr(SPRN_IVOR9);
|
|
|
|
|
ivor[10] = mfspr(SPRN_IVOR10);
|
|
|
|
|
ivor[11] = mfspr(SPRN_IVOR11);
|
|
|
|
|
ivor[12] = mfspr(SPRN_IVOR12);
|
|
|
|
|
ivor[13] = mfspr(SPRN_IVOR13);
|
|
|
|
|
ivor[14] = mfspr(SPRN_IVOR14);
|
|
|
|
|
ivor[15] = mfspr(SPRN_IVOR15);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
|
if (ivor[i] > max_ivor)
|
2013-01-15 22:24:39 +00:00
|
|
|
max_ivor = i;
|
2008-11-05 15:36:13 +00:00
|
|
|
|
2013-01-15 22:24:39 +00:00
|
|
|
handler_len = handler[i + 1] - handler[i];
|
2008-11-05 15:36:13 +00:00
|
|
|
memcpy((void *)kvmppc_booke_handlers + ivor[i],
|
2013-01-15 22:24:39 +00:00
|
|
|
(void *)handler[i], handler_len);
|
2008-11-05 15:36:13 +00:00
|
|
|
}
|
2013-01-15 22:24:39 +00:00
|
|
|
|
|
|
|
|
handler_len = handler[max_ivor + 1] - handler[max_ivor];
|
|
|
|
|
flush_icache_range(kvmppc_booke_handlers, kvmppc_booke_handlers +
|
|
|
|
|
ivor[max_ivor] + handler_len);
|
2011-12-20 15:34:43 +00:00
|
|
|
#endif /* !BOOKE_HV */
|
2008-11-05 15:36:18 +00:00
|
|
|
return 0;
|
2008-11-05 15:36:13 +00:00
|
|
|
}
|
|
|
|
|
|
2008-11-05 15:36:18 +00:00
|
|
|
void __exit kvmppc_booke_exit(void)
|
2008-11-05 15:36:13 +00:00
|
|
|
{
|
|
|
|
|
free_pages(kvmppc_booke_handlers, VCPU_SIZE_ORDER);
|
|
|
|
|
kvm_exit();
|
|
|
|
|
}
|
