mirror of
https://github.com/torvalds/linux.git
synced 2024-11-10 22:21:40 +00:00
KVM: PPC: Remove 440 support
The 440 target hasn't been properly functioning for a few releases and before I was the only one who fixes a very serious bug that indicates to me that nobody used it before either. Furthermore KVM on 440 is slow to the extent of unusable. We don't have to carry along completely unused code. Remove 440 and give us one less thing to worry about. Signed-off-by: Alexander Graf <agraf@suse.de>
This commit is contained in:
parent
8c95ead603
commit
b2677b8dd8
@ -17,8 +17,6 @@ firmware-assisted-dump.txt
|
||||
- Documentation on the firmware assisted dump mechanism "fadump".
|
||||
hvcs.txt
|
||||
- IBM "Hypervisor Virtual Console Server" Installation Guide
|
||||
kvm_440.txt
|
||||
- Various notes on the implementation of KVM for PowerPC 440.
|
||||
mpc52xx.txt
|
||||
- Linux 2.6.x on MPC52xx family
|
||||
pmu-ebb.txt
|
||||
|
@ -1,41 +0,0 @@
|
||||
Hollis Blanchard <hollisb@us.ibm.com>
|
||||
15 Apr 2008
|
||||
|
||||
Various notes on the implementation of KVM for PowerPC 440:
|
||||
|
||||
To enforce isolation, host userspace, guest kernel, and guest userspace all
|
||||
run at user privilege level. Only the host kernel runs in supervisor mode.
|
||||
Executing privileged instructions in the guest traps into KVM (in the host
|
||||
kernel), where we decode and emulate them. Through this technique, unmodified
|
||||
440 Linux kernels can be run (slowly) as guests. Future performance work will
|
||||
focus on reducing the overhead and frequency of these traps.
|
||||
|
||||
The usual code flow is started from userspace invoking an "run" ioctl, which
|
||||
causes KVM to switch into guest context. We use IVPR to hijack the host
|
||||
interrupt vectors while running the guest, which allows us to direct all
|
||||
interrupts to kvmppc_handle_interrupt(). At this point, we could either
|
||||
- handle the interrupt completely (e.g. emulate "mtspr SPRG0"), or
|
||||
- let the host interrupt handler run (e.g. when the decrementer fires), or
|
||||
- return to host userspace (e.g. when the guest performs device MMIO)
|
||||
|
||||
Address spaces: We take advantage of the fact that Linux doesn't use the AS=1
|
||||
address space (in host or guest), which gives us virtual address space to use
|
||||
for guest mappings. While the guest is running, the host kernel remains mapped
|
||||
in AS=0, but the guest can only use AS=1 mappings.
|
||||
|
||||
TLB entries: The TLB entries covering the host linear mapping remain
|
||||
present while running the guest. This reduces the overhead of lightweight
|
||||
exits, which are handled by KVM running in the host kernel. We keep three
|
||||
copies of the TLB:
|
||||
- guest TLB: contents of the TLB as the guest sees it
|
||||
- shadow TLB: the TLB that is actually in hardware while guest is running
|
||||
- host TLB: to restore TLB state when context switching guest -> host
|
||||
When a TLB miss occurs because a mapping was not present in the shadow TLB,
|
||||
but was present in the guest TLB, KVM handles the fault without invoking the
|
||||
guest. Large guest pages are backed by multiple 4KB shadow pages through this
|
||||
mechanism.
|
||||
|
||||
IO: MMIO and DCR accesses are emulated by userspace. We use virtio for network
|
||||
and block IO, so those drivers must be enabled in the guest. It's possible
|
||||
that some qemu device emulation (e.g. e1000 or rtl8139) may also work with
|
||||
little effort.
|
@ -202,9 +202,7 @@ config PPC_EARLY_DEBUG_BEAT
|
||||
|
||||
config PPC_EARLY_DEBUG_44x
|
||||
bool "Early serial debugging for IBM/AMCC 44x CPUs"
|
||||
# PPC_EARLY_DEBUG on 440 leaves AS=1 mappings above the TLB high water
|
||||
# mark, which doesn't work with current 440 KVM.
|
||||
depends on 44x && !KVM
|
||||
depends on 44x
|
||||
help
|
||||
Select this to enable early debugging for IBM 44x chips via the
|
||||
inbuilt serial port. If you enable this, ensure you set
|
||||
|
@ -127,4 +127,3 @@ CONFIG_CRYPTO_PCBC=y
|
||||
# CONFIG_CRYPTO_ANSI_CPRNG is not set
|
||||
# CONFIG_CRYPTO_HW is not set
|
||||
CONFIG_VIRTUALIZATION=y
|
||||
CONFIG_KVM_440=y
|
||||
|
@ -1,67 +0,0 @@
|
||||
/*
|
||||
* 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. 2008
|
||||
*
|
||||
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef __ASM_44X_H__
|
||||
#define __ASM_44X_H__
|
||||
|
||||
#include <linux/kvm_host.h>
|
||||
|
||||
#define PPC44x_TLB_SIZE 64
|
||||
|
||||
/* If the guest is expecting it, this can be as large as we like; we'd just
|
||||
* need to find some way of advertising it. */
|
||||
#define KVM44x_GUEST_TLB_SIZE 64
|
||||
|
||||
struct kvmppc_44x_tlbe {
|
||||
u32 tid; /* Only the low 8 bits are used. */
|
||||
u32 word0;
|
||||
u32 word1;
|
||||
u32 word2;
|
||||
};
|
||||
|
||||
struct kvmppc_44x_shadow_ref {
|
||||
struct page *page;
|
||||
u16 gtlb_index;
|
||||
u8 writeable;
|
||||
u8 tid;
|
||||
};
|
||||
|
||||
struct kvmppc_vcpu_44x {
|
||||
/* Unmodified copy of the guest's TLB. */
|
||||
struct kvmppc_44x_tlbe guest_tlb[KVM44x_GUEST_TLB_SIZE];
|
||||
|
||||
/* References to guest pages in the hardware TLB. */
|
||||
struct kvmppc_44x_shadow_ref shadow_refs[PPC44x_TLB_SIZE];
|
||||
|
||||
/* State of the shadow TLB at guest context switch time. */
|
||||
struct kvmppc_44x_tlbe shadow_tlb[PPC44x_TLB_SIZE];
|
||||
u8 shadow_tlb_mod[PPC44x_TLB_SIZE];
|
||||
|
||||
struct kvm_vcpu vcpu;
|
||||
};
|
||||
|
||||
static inline struct kvmppc_vcpu_44x *to_44x(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return container_of(vcpu, struct kvmppc_vcpu_44x, vcpu);
|
||||
}
|
||||
|
||||
void kvmppc_44x_tlb_put(struct kvm_vcpu *vcpu);
|
||||
void kvmppc_44x_tlb_load(struct kvm_vcpu *vcpu);
|
||||
|
||||
#endif /* __ASM_44X_H__ */
|
@ -33,7 +33,6 @@
|
||||
/* IVPR must be 64KiB-aligned. */
|
||||
#define VCPU_SIZE_ORDER 4
|
||||
#define VCPU_SIZE_LOG (VCPU_SIZE_ORDER + 12)
|
||||
#define VCPU_TLB_PGSZ PPC44x_TLB_64K
|
||||
#define VCPU_SIZE_BYTES (1<<VCPU_SIZE_LOG)
|
||||
|
||||
#define BOOKE_INTERRUPT_CRITICAL 0
|
||||
|
@ -49,7 +49,6 @@
|
||||
#define KVM_NR_IRQCHIPS 1
|
||||
#define KVM_IRQCHIP_NUM_PINS 256
|
||||
|
||||
#if !defined(CONFIG_KVM_440)
|
||||
#include <linux/mmu_notifier.h>
|
||||
|
||||
#define KVM_ARCH_WANT_MMU_NOTIFIER
|
||||
@ -62,8 +61,6 @@ extern int kvm_age_hva(struct kvm *kvm, unsigned long hva);
|
||||
extern int kvm_test_age_hva(struct kvm *kvm, unsigned long hva);
|
||||
extern void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte);
|
||||
|
||||
#endif
|
||||
|
||||
#define HPTEG_CACHE_NUM (1 << 15)
|
||||
#define HPTEG_HASH_BITS_PTE 13
|
||||
#define HPTEG_HASH_BITS_PTE_LONG 12
|
||||
|
@ -1,237 +0,0 @@
|
||||
/*
|
||||
* 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. 2008
|
||||
*
|
||||
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
||||
*/
|
||||
|
||||
#include <linux/kvm_host.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/miscdevice.h>
|
||||
|
||||
#include <asm/reg.h>
|
||||
#include <asm/cputable.h>
|
||||
#include <asm/tlbflush.h>
|
||||
#include <asm/kvm_44x.h>
|
||||
#include <asm/kvm_ppc.h>
|
||||
|
||||
#include "44x_tlb.h"
|
||||
#include "booke.h"
|
||||
|
||||
static void kvmppc_core_vcpu_load_44x(struct kvm_vcpu *vcpu, int cpu)
|
||||
{
|
||||
kvmppc_booke_vcpu_load(vcpu, cpu);
|
||||
kvmppc_44x_tlb_load(vcpu);
|
||||
}
|
||||
|
||||
static void kvmppc_core_vcpu_put_44x(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
kvmppc_44x_tlb_put(vcpu);
|
||||
kvmppc_booke_vcpu_put(vcpu);
|
||||
}
|
||||
|
||||
int kvmppc_core_check_processor_compat(void)
|
||||
{
|
||||
int r;
|
||||
|
||||
if (strncmp(cur_cpu_spec->platform, "ppc440", 6) == 0)
|
||||
r = 0;
|
||||
else
|
||||
r = -ENOTSUPP;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
int kvmppc_core_vcpu_setup(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
struct kvmppc_44x_tlbe *tlbe = &vcpu_44x->guest_tlb[0];
|
||||
int i;
|
||||
|
||||
tlbe->tid = 0;
|
||||
tlbe->word0 = PPC44x_TLB_16M | PPC44x_TLB_VALID;
|
||||
tlbe->word1 = 0;
|
||||
tlbe->word2 = PPC44x_TLB_SX | PPC44x_TLB_SW | PPC44x_TLB_SR;
|
||||
|
||||
tlbe++;
|
||||
tlbe->tid = 0;
|
||||
tlbe->word0 = 0xef600000 | PPC44x_TLB_4K | PPC44x_TLB_VALID;
|
||||
tlbe->word1 = 0xef600000;
|
||||
tlbe->word2 = PPC44x_TLB_SX | PPC44x_TLB_SW | PPC44x_TLB_SR
|
||||
| PPC44x_TLB_I | PPC44x_TLB_G;
|
||||
|
||||
/* Since the guest can directly access the timebase, it must know the
|
||||
* real timebase frequency. Accordingly, it must see the state of
|
||||
* CCR1[TCS]. */
|
||||
/* XXX CCR1 doesn't exist on all 440 SoCs. */
|
||||
vcpu->arch.ccr1 = mfspr(SPRN_CCR1);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(vcpu_44x->shadow_refs); i++)
|
||||
vcpu_44x->shadow_refs[i].gtlb_index = -1;
|
||||
|
||||
vcpu->arch.cpu_type = KVM_CPU_440;
|
||||
vcpu->arch.pvr = mfspr(SPRN_PVR);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 'linear_address' is actually an encoding of AS|PID|EADDR . */
|
||||
int kvmppc_core_vcpu_translate(struct kvm_vcpu *vcpu,
|
||||
struct kvm_translation *tr)
|
||||
{
|
||||
int index;
|
||||
gva_t eaddr;
|
||||
u8 pid;
|
||||
u8 as;
|
||||
|
||||
eaddr = tr->linear_address;
|
||||
pid = (tr->linear_address >> 32) & 0xff;
|
||||
as = (tr->linear_address >> 40) & 0x1;
|
||||
|
||||
index = kvmppc_44x_tlb_index(vcpu, eaddr, pid, as);
|
||||
if (index == -1) {
|
||||
tr->valid = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
tr->physical_address = kvmppc_mmu_xlate(vcpu, index, eaddr);
|
||||
/* XXX what does "writeable" and "usermode" even mean? */
|
||||
tr->valid = 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int kvmppc_core_get_sregs_44x(struct kvm_vcpu *vcpu,
|
||||
struct kvm_sregs *sregs)
|
||||
{
|
||||
return kvmppc_get_sregs_ivor(vcpu, sregs);
|
||||
}
|
||||
|
||||
static int kvmppc_core_set_sregs_44x(struct kvm_vcpu *vcpu,
|
||||
struct kvm_sregs *sregs)
|
||||
{
|
||||
return kvmppc_set_sregs_ivor(vcpu, sregs);
|
||||
}
|
||||
|
||||
static int kvmppc_get_one_reg_44x(struct kvm_vcpu *vcpu, u64 id,
|
||||
union kvmppc_one_reg *val)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int kvmppc_set_one_reg_44x(struct kvm_vcpu *vcpu, u64 id,
|
||||
union kvmppc_one_reg *val)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static struct kvm_vcpu *kvmppc_core_vcpu_create_44x(struct kvm *kvm,
|
||||
unsigned int id)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x;
|
||||
struct kvm_vcpu *vcpu;
|
||||
int err;
|
||||
|
||||
vcpu_44x = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
|
||||
if (!vcpu_44x) {
|
||||
err = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
vcpu = &vcpu_44x->vcpu;
|
||||
err = kvm_vcpu_init(vcpu, kvm, id);
|
||||
if (err)
|
||||
goto free_vcpu;
|
||||
|
||||
vcpu->arch.shared = (void*)__get_free_page(GFP_KERNEL|__GFP_ZERO);
|
||||
if (!vcpu->arch.shared)
|
||||
goto uninit_vcpu;
|
||||
|
||||
return vcpu;
|
||||
|
||||
uninit_vcpu:
|
||||
kvm_vcpu_uninit(vcpu);
|
||||
free_vcpu:
|
||||
kmem_cache_free(kvm_vcpu_cache, vcpu_44x);
|
||||
out:
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
|
||||
static void kvmppc_core_vcpu_free_44x(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
|
||||
free_page((unsigned long)vcpu->arch.shared);
|
||||
kvm_vcpu_uninit(vcpu);
|
||||
kmem_cache_free(kvm_vcpu_cache, vcpu_44x);
|
||||
}
|
||||
|
||||
static int kvmppc_core_init_vm_44x(struct kvm *kvm)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void kvmppc_core_destroy_vm_44x(struct kvm *kvm)
|
||||
{
|
||||
}
|
||||
|
||||
static struct kvmppc_ops kvm_ops_44x = {
|
||||
.get_sregs = kvmppc_core_get_sregs_44x,
|
||||
.set_sregs = kvmppc_core_set_sregs_44x,
|
||||
.get_one_reg = kvmppc_get_one_reg_44x,
|
||||
.set_one_reg = kvmppc_set_one_reg_44x,
|
||||
.vcpu_load = kvmppc_core_vcpu_load_44x,
|
||||
.vcpu_put = kvmppc_core_vcpu_put_44x,
|
||||
.vcpu_create = kvmppc_core_vcpu_create_44x,
|
||||
.vcpu_free = kvmppc_core_vcpu_free_44x,
|
||||
.mmu_destroy = kvmppc_mmu_destroy_44x,
|
||||
.init_vm = kvmppc_core_init_vm_44x,
|
||||
.destroy_vm = kvmppc_core_destroy_vm_44x,
|
||||
.emulate_op = kvmppc_core_emulate_op_44x,
|
||||
.emulate_mtspr = kvmppc_core_emulate_mtspr_44x,
|
||||
.emulate_mfspr = kvmppc_core_emulate_mfspr_44x,
|
||||
};
|
||||
|
||||
static int __init kvmppc_44x_init(void)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = kvmppc_booke_init();
|
||||
if (r)
|
||||
goto err_out;
|
||||
|
||||
r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_44x), 0, THIS_MODULE);
|
||||
if (r)
|
||||
goto err_out;
|
||||
kvm_ops_44x.owner = THIS_MODULE;
|
||||
kvmppc_pr_ops = &kvm_ops_44x;
|
||||
|
||||
err_out:
|
||||
return r;
|
||||
}
|
||||
|
||||
static void __exit kvmppc_44x_exit(void)
|
||||
{
|
||||
kvmppc_pr_ops = NULL;
|
||||
kvmppc_booke_exit();
|
||||
}
|
||||
|
||||
module_init(kvmppc_44x_init);
|
||||
module_exit(kvmppc_44x_exit);
|
||||
MODULE_ALIAS_MISCDEV(KVM_MINOR);
|
||||
MODULE_ALIAS("devname:kvm");
|
@ -1,194 +0,0 @@
|
||||
/*
|
||||
* 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. 2008
|
||||
*
|
||||
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
||||
*/
|
||||
|
||||
#include <asm/kvm_ppc.h>
|
||||
#include <asm/dcr.h>
|
||||
#include <asm/dcr-regs.h>
|
||||
#include <asm/disassemble.h>
|
||||
#include <asm/kvm_44x.h>
|
||||
#include "timing.h"
|
||||
|
||||
#include "booke.h"
|
||||
#include "44x_tlb.h"
|
||||
|
||||
#define XOP_MFDCRX 259
|
||||
#define XOP_MFDCR 323
|
||||
#define XOP_MTDCRX 387
|
||||
#define XOP_MTDCR 451
|
||||
#define XOP_TLBSX 914
|
||||
#define XOP_ICCCI 966
|
||||
#define XOP_TLBWE 978
|
||||
|
||||
static int emulate_mtdcr(struct kvm_vcpu *vcpu, int rs, int dcrn)
|
||||
{
|
||||
/* emulate some access in kernel */
|
||||
switch (dcrn) {
|
||||
case DCRN_CPR0_CONFIG_ADDR:
|
||||
vcpu->arch.cpr0_cfgaddr = kvmppc_get_gpr(vcpu, rs);
|
||||
return EMULATE_DONE;
|
||||
default:
|
||||
vcpu->run->dcr.dcrn = dcrn;
|
||||
vcpu->run->dcr.data = kvmppc_get_gpr(vcpu, rs);
|
||||
vcpu->run->dcr.is_write = 1;
|
||||
vcpu->arch.dcr_is_write = 1;
|
||||
vcpu->arch.dcr_needed = 1;
|
||||
kvmppc_account_exit(vcpu, DCR_EXITS);
|
||||
return EMULATE_DO_DCR;
|
||||
}
|
||||
}
|
||||
|
||||
static int emulate_mfdcr(struct kvm_vcpu *vcpu, int rt, int dcrn)
|
||||
{
|
||||
/* The guest may access CPR0 registers to determine the timebase
|
||||
* frequency, and it must know the real host frequency because it
|
||||
* can directly access the timebase registers.
|
||||
*
|
||||
* It would be possible to emulate those accesses in userspace,
|
||||
* but userspace can really only figure out the end frequency.
|
||||
* We could decompose that into the factors that compute it, but
|
||||
* that's tricky math, and it's easier to just report the real
|
||||
* CPR0 values.
|
||||
*/
|
||||
switch (dcrn) {
|
||||
case DCRN_CPR0_CONFIG_ADDR:
|
||||
kvmppc_set_gpr(vcpu, rt, vcpu->arch.cpr0_cfgaddr);
|
||||
break;
|
||||
case DCRN_CPR0_CONFIG_DATA:
|
||||
local_irq_disable();
|
||||
mtdcr(DCRN_CPR0_CONFIG_ADDR,
|
||||
vcpu->arch.cpr0_cfgaddr);
|
||||
kvmppc_set_gpr(vcpu, rt,
|
||||
mfdcr(DCRN_CPR0_CONFIG_DATA));
|
||||
local_irq_enable();
|
||||
break;
|
||||
default:
|
||||
vcpu->run->dcr.dcrn = dcrn;
|
||||
vcpu->run->dcr.data = 0;
|
||||
vcpu->run->dcr.is_write = 0;
|
||||
vcpu->arch.dcr_is_write = 0;
|
||||
vcpu->arch.io_gpr = rt;
|
||||
vcpu->arch.dcr_needed = 1;
|
||||
kvmppc_account_exit(vcpu, DCR_EXITS);
|
||||
return EMULATE_DO_DCR;
|
||||
}
|
||||
|
||||
return EMULATE_DONE;
|
||||
}
|
||||
|
||||
int kvmppc_core_emulate_op_44x(struct kvm_run *run, struct kvm_vcpu *vcpu,
|
||||
unsigned int inst, int *advance)
|
||||
{
|
||||
int emulated = EMULATE_DONE;
|
||||
int dcrn = get_dcrn(inst);
|
||||
int ra = get_ra(inst);
|
||||
int rb = get_rb(inst);
|
||||
int rc = get_rc(inst);
|
||||
int rs = get_rs(inst);
|
||||
int rt = get_rt(inst);
|
||||
int ws = get_ws(inst);
|
||||
|
||||
switch (get_op(inst)) {
|
||||
case 31:
|
||||
switch (get_xop(inst)) {
|
||||
|
||||
case XOP_MFDCR:
|
||||
emulated = emulate_mfdcr(vcpu, rt, dcrn);
|
||||
break;
|
||||
|
||||
case XOP_MFDCRX:
|
||||
emulated = emulate_mfdcr(vcpu, rt,
|
||||
kvmppc_get_gpr(vcpu, ra));
|
||||
break;
|
||||
|
||||
case XOP_MTDCR:
|
||||
emulated = emulate_mtdcr(vcpu, rs, dcrn);
|
||||
break;
|
||||
|
||||
case XOP_MTDCRX:
|
||||
emulated = emulate_mtdcr(vcpu, rs,
|
||||
kvmppc_get_gpr(vcpu, ra));
|
||||
break;
|
||||
|
||||
case XOP_TLBWE:
|
||||
emulated = kvmppc_44x_emul_tlbwe(vcpu, ra, rs, ws);
|
||||
break;
|
||||
|
||||
case XOP_TLBSX:
|
||||
emulated = kvmppc_44x_emul_tlbsx(vcpu, rt, ra, rb, rc);
|
||||
break;
|
||||
|
||||
case XOP_ICCCI:
|
||||
break;
|
||||
|
||||
default:
|
||||
emulated = EMULATE_FAIL;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
emulated = EMULATE_FAIL;
|
||||
}
|
||||
|
||||
if (emulated == EMULATE_FAIL)
|
||||
emulated = kvmppc_booke_emulate_op(run, vcpu, inst, advance);
|
||||
|
||||
return emulated;
|
||||
}
|
||||
|
||||
int kvmppc_core_emulate_mtspr_44x(struct kvm_vcpu *vcpu, int sprn, ulong spr_val)
|
||||
{
|
||||
int emulated = EMULATE_DONE;
|
||||
|
||||
switch (sprn) {
|
||||
case SPRN_PID:
|
||||
kvmppc_set_pid(vcpu, spr_val); break;
|
||||
case SPRN_MMUCR:
|
||||
vcpu->arch.mmucr = spr_val; break;
|
||||
case SPRN_CCR0:
|
||||
vcpu->arch.ccr0 = spr_val; break;
|
||||
case SPRN_CCR1:
|
||||
vcpu->arch.ccr1 = spr_val; break;
|
||||
default:
|
||||
emulated = kvmppc_booke_emulate_mtspr(vcpu, sprn, spr_val);
|
||||
}
|
||||
|
||||
return emulated;
|
||||
}
|
||||
|
||||
int kvmppc_core_emulate_mfspr_44x(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val)
|
||||
{
|
||||
int emulated = EMULATE_DONE;
|
||||
|
||||
switch (sprn) {
|
||||
case SPRN_PID:
|
||||
*spr_val = vcpu->arch.pid; break;
|
||||
case SPRN_MMUCR:
|
||||
*spr_val = vcpu->arch.mmucr; break;
|
||||
case SPRN_CCR0:
|
||||
*spr_val = vcpu->arch.ccr0; break;
|
||||
case SPRN_CCR1:
|
||||
*spr_val = vcpu->arch.ccr1; break;
|
||||
default:
|
||||
emulated = kvmppc_booke_emulate_mfspr(vcpu, sprn, spr_val);
|
||||
}
|
||||
|
||||
return emulated;
|
||||
}
|
||||
|
@ -1,528 +0,0 @@
|
||||
/*
|
||||
* 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
|
||||
*
|
||||
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/kvm.h>
|
||||
#include <linux/kvm_host.h>
|
||||
#include <linux/highmem.h>
|
||||
|
||||
#include <asm/tlbflush.h>
|
||||
#include <asm/mmu-44x.h>
|
||||
#include <asm/kvm_ppc.h>
|
||||
#include <asm/kvm_44x.h>
|
||||
#include "timing.h"
|
||||
|
||||
#include "44x_tlb.h"
|
||||
#include "trace.h"
|
||||
|
||||
#ifndef PPC44x_TLBE_SIZE
|
||||
#define PPC44x_TLBE_SIZE PPC44x_TLB_4K
|
||||
#endif
|
||||
|
||||
#define PAGE_SIZE_4K (1<<12)
|
||||
#define PAGE_MASK_4K (~(PAGE_SIZE_4K - 1))
|
||||
|
||||
#define PPC44x_TLB_UATTR_MASK \
|
||||
(PPC44x_TLB_U0|PPC44x_TLB_U1|PPC44x_TLB_U2|PPC44x_TLB_U3)
|
||||
#define PPC44x_TLB_USER_PERM_MASK (PPC44x_TLB_UX|PPC44x_TLB_UR|PPC44x_TLB_UW)
|
||||
#define PPC44x_TLB_SUPER_PERM_MASK (PPC44x_TLB_SX|PPC44x_TLB_SR|PPC44x_TLB_SW)
|
||||
|
||||
#ifdef DEBUG
|
||||
void kvmppc_dump_tlbs(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
struct kvmppc_44x_tlbe *tlbe;
|
||||
int i;
|
||||
|
||||
printk("vcpu %d TLB dump:\n", vcpu->vcpu_id);
|
||||
printk("| %2s | %3s | %8s | %8s | %8s |\n",
|
||||
"nr", "tid", "word0", "word1", "word2");
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(vcpu_44x->guest_tlb); i++) {
|
||||
tlbe = &vcpu_44x->guest_tlb[i];
|
||||
if (tlbe->word0 & PPC44x_TLB_VALID)
|
||||
printk(" G%2d | %02X | %08X | %08X | %08X |\n",
|
||||
i, tlbe->tid, tlbe->word0, tlbe->word1,
|
||||
tlbe->word2);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline void kvmppc_44x_tlbie(unsigned int index)
|
||||
{
|
||||
/* 0 <= index < 64, so the V bit is clear and we can use the index as
|
||||
* word0. */
|
||||
asm volatile(
|
||||
"tlbwe %[index], %[index], 0\n"
|
||||
:
|
||||
: [index] "r"(index)
|
||||
);
|
||||
}
|
||||
|
||||
static inline void kvmppc_44x_tlbre(unsigned int index,
|
||||
struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
asm volatile(
|
||||
"tlbre %[word0], %[index], 0\n"
|
||||
"mfspr %[tid], %[sprn_mmucr]\n"
|
||||
"andi. %[tid], %[tid], 0xff\n"
|
||||
"tlbre %[word1], %[index], 1\n"
|
||||
"tlbre %[word2], %[index], 2\n"
|
||||
: [word0] "=r"(tlbe->word0),
|
||||
[word1] "=r"(tlbe->word1),
|
||||
[word2] "=r"(tlbe->word2),
|
||||
[tid] "=r"(tlbe->tid)
|
||||
: [index] "r"(index),
|
||||
[sprn_mmucr] "i"(SPRN_MMUCR)
|
||||
: "cc"
|
||||
);
|
||||
}
|
||||
|
||||
static inline void kvmppc_44x_tlbwe(unsigned int index,
|
||||
struct kvmppc_44x_tlbe *stlbe)
|
||||
{
|
||||
unsigned long tmp;
|
||||
|
||||
asm volatile(
|
||||
"mfspr %[tmp], %[sprn_mmucr]\n"
|
||||
"rlwimi %[tmp], %[tid], 0, 0xff\n"
|
||||
"mtspr %[sprn_mmucr], %[tmp]\n"
|
||||
"tlbwe %[word0], %[index], 0\n"
|
||||
"tlbwe %[word1], %[index], 1\n"
|
||||
"tlbwe %[word2], %[index], 2\n"
|
||||
: [tmp] "=&r"(tmp)
|
||||
: [word0] "r"(stlbe->word0),
|
||||
[word1] "r"(stlbe->word1),
|
||||
[word2] "r"(stlbe->word2),
|
||||
[tid] "r"(stlbe->tid),
|
||||
[index] "r"(index),
|
||||
[sprn_mmucr] "i"(SPRN_MMUCR)
|
||||
);
|
||||
}
|
||||
|
||||
static u32 kvmppc_44x_tlb_shadow_attrib(u32 attrib, int usermode)
|
||||
{
|
||||
/* We only care about the guest's permission and user bits. */
|
||||
attrib &= PPC44x_TLB_PERM_MASK|PPC44x_TLB_UATTR_MASK;
|
||||
|
||||
if (!usermode) {
|
||||
/* Guest is in supervisor mode, so we need to translate guest
|
||||
* supervisor permissions into user permissions. */
|
||||
attrib &= ~PPC44x_TLB_USER_PERM_MASK;
|
||||
attrib |= (attrib & PPC44x_TLB_SUPER_PERM_MASK) << 3;
|
||||
}
|
||||
|
||||
/* Make sure host can always access this memory. */
|
||||
attrib |= PPC44x_TLB_SX|PPC44x_TLB_SR|PPC44x_TLB_SW;
|
||||
|
||||
/* WIMGE = 0b00100 */
|
||||
attrib |= PPC44x_TLB_M;
|
||||
|
||||
return attrib;
|
||||
}
|
||||
|
||||
/* Load shadow TLB back into hardware. */
|
||||
void kvmppc_44x_tlb_load(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= tlb_44x_hwater; i++) {
|
||||
struct kvmppc_44x_tlbe *stlbe = &vcpu_44x->shadow_tlb[i];
|
||||
|
||||
if (get_tlb_v(stlbe) && get_tlb_ts(stlbe))
|
||||
kvmppc_44x_tlbwe(i, stlbe);
|
||||
}
|
||||
}
|
||||
|
||||
static void kvmppc_44x_tlbe_set_modified(struct kvmppc_vcpu_44x *vcpu_44x,
|
||||
unsigned int i)
|
||||
{
|
||||
vcpu_44x->shadow_tlb_mod[i] = 1;
|
||||
}
|
||||
|
||||
/* Save hardware TLB to the vcpu, and invalidate all guest mappings. */
|
||||
void kvmppc_44x_tlb_put(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= tlb_44x_hwater; i++) {
|
||||
struct kvmppc_44x_tlbe *stlbe = &vcpu_44x->shadow_tlb[i];
|
||||
|
||||
if (vcpu_44x->shadow_tlb_mod[i])
|
||||
kvmppc_44x_tlbre(i, stlbe);
|
||||
|
||||
if (get_tlb_v(stlbe) && get_tlb_ts(stlbe))
|
||||
kvmppc_44x_tlbie(i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Search the guest TLB for a matching entry. */
|
||||
int kvmppc_44x_tlb_index(struct kvm_vcpu *vcpu, gva_t eaddr, unsigned int pid,
|
||||
unsigned int as)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
/* XXX Replace loop with fancy data structures. */
|
||||
for (i = 0; i < ARRAY_SIZE(vcpu_44x->guest_tlb); i++) {
|
||||
struct kvmppc_44x_tlbe *tlbe = &vcpu_44x->guest_tlb[i];
|
||||
unsigned int tid;
|
||||
|
||||
if (eaddr < get_tlb_eaddr(tlbe))
|
||||
continue;
|
||||
|
||||
if (eaddr > get_tlb_end(tlbe))
|
||||
continue;
|
||||
|
||||
tid = get_tlb_tid(tlbe);
|
||||
if (tid && (tid != pid))
|
||||
continue;
|
||||
|
||||
if (!get_tlb_v(tlbe))
|
||||
continue;
|
||||
|
||||
if (get_tlb_ts(tlbe) != as)
|
||||
continue;
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
gpa_t kvmppc_mmu_xlate(struct kvm_vcpu *vcpu, unsigned int gtlb_index,
|
||||
gva_t eaddr)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
struct kvmppc_44x_tlbe *gtlbe = &vcpu_44x->guest_tlb[gtlb_index];
|
||||
unsigned int pgmask = get_tlb_bytes(gtlbe) - 1;
|
||||
|
||||
return get_tlb_raddr(gtlbe) | (eaddr & pgmask);
|
||||
}
|
||||
|
||||
int kvmppc_mmu_itlb_index(struct kvm_vcpu *vcpu, gva_t eaddr)
|
||||
{
|
||||
unsigned int as = !!(vcpu->arch.shared->msr & MSR_IS);
|
||||
|
||||
return kvmppc_44x_tlb_index(vcpu, eaddr, vcpu->arch.pid, as);
|
||||
}
|
||||
|
||||
int kvmppc_mmu_dtlb_index(struct kvm_vcpu *vcpu, gva_t eaddr)
|
||||
{
|
||||
unsigned int as = !!(vcpu->arch.shared->msr & MSR_DS);
|
||||
|
||||
return kvmppc_44x_tlb_index(vcpu, eaddr, vcpu->arch.pid, as);
|
||||
}
|
||||
|
||||
void kvmppc_mmu_itlb_miss(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
}
|
||||
|
||||
void kvmppc_mmu_dtlb_miss(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
}
|
||||
|
||||
static void kvmppc_44x_shadow_release(struct kvmppc_vcpu_44x *vcpu_44x,
|
||||
unsigned int stlb_index)
|
||||
{
|
||||
struct kvmppc_44x_shadow_ref *ref = &vcpu_44x->shadow_refs[stlb_index];
|
||||
|
||||
if (!ref->page)
|
||||
return;
|
||||
|
||||
/* Discard from the TLB. */
|
||||
/* Note: we could actually invalidate a host mapping, if the host overwrote
|
||||
* this TLB entry since we inserted a guest mapping. */
|
||||
kvmppc_44x_tlbie(stlb_index);
|
||||
|
||||
/* Now release the page. */
|
||||
if (ref->writeable)
|
||||
kvm_release_page_dirty(ref->page);
|
||||
else
|
||||
kvm_release_page_clean(ref->page);
|
||||
|
||||
ref->page = NULL;
|
||||
|
||||
/* XXX set tlb_44x_index to stlb_index? */
|
||||
|
||||
trace_kvm_stlb_inval(stlb_index);
|
||||
}
|
||||
|
||||
void kvmppc_mmu_destroy_44x(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= tlb_44x_hwater; i++)
|
||||
kvmppc_44x_shadow_release(vcpu_44x, i);
|
||||
}
|
||||
|
||||
/**
|
||||
* kvmppc_mmu_map -- create a host mapping for guest memory
|
||||
*
|
||||
* If the guest wanted a larger page than the host supports, only the first
|
||||
* host page is mapped here and the rest are demand faulted.
|
||||
*
|
||||
* If the guest wanted a smaller page than the host page size, we map only the
|
||||
* guest-size page (i.e. not a full host page mapping).
|
||||
*
|
||||
* Caller must ensure that the specified guest TLB entry is safe to insert into
|
||||
* the shadow TLB.
|
||||
*/
|
||||
void kvmppc_mmu_map(struct kvm_vcpu *vcpu, u64 gvaddr, gpa_t gpaddr,
|
||||
unsigned int gtlb_index)
|
||||
{
|
||||
struct kvmppc_44x_tlbe stlbe;
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
struct kvmppc_44x_tlbe *gtlbe = &vcpu_44x->guest_tlb[gtlb_index];
|
||||
struct kvmppc_44x_shadow_ref *ref;
|
||||
struct page *new_page;
|
||||
hpa_t hpaddr;
|
||||
gfn_t gfn;
|
||||
u32 asid = gtlbe->tid;
|
||||
u32 flags = gtlbe->word2;
|
||||
u32 max_bytes = get_tlb_bytes(gtlbe);
|
||||
unsigned int victim;
|
||||
|
||||
/* Select TLB entry to clobber. Indirectly guard against races with the TLB
|
||||
* miss handler by disabling interrupts. */
|
||||
local_irq_disable();
|
||||
victim = ++tlb_44x_index;
|
||||
if (victim > tlb_44x_hwater)
|
||||
victim = 0;
|
||||
tlb_44x_index = victim;
|
||||
local_irq_enable();
|
||||
|
||||
/* Get reference to new page. */
|
||||
gfn = gpaddr >> PAGE_SHIFT;
|
||||
new_page = gfn_to_page(vcpu->kvm, gfn);
|
||||
if (is_error_page(new_page)) {
|
||||
printk(KERN_ERR "Couldn't get guest page for gfn %llx!\n",
|
||||
(unsigned long long)gfn);
|
||||
return;
|
||||
}
|
||||
hpaddr = page_to_phys(new_page);
|
||||
|
||||
/* Invalidate any previous shadow mappings. */
|
||||
kvmppc_44x_shadow_release(vcpu_44x, victim);
|
||||
|
||||
/* XXX Make sure (va, size) doesn't overlap any other
|
||||
* entries. 440x6 user manual says the result would be
|
||||
* "undefined." */
|
||||
|
||||
/* XXX what about AS? */
|
||||
|
||||
/* Force TS=1 for all guest mappings. */
|
||||
stlbe.word0 = PPC44x_TLB_VALID | PPC44x_TLB_TS;
|
||||
|
||||
if (max_bytes >= PAGE_SIZE) {
|
||||
/* Guest mapping is larger than or equal to host page size. We can use
|
||||
* a "native" host mapping. */
|
||||
stlbe.word0 |= (gvaddr & PAGE_MASK) | PPC44x_TLBE_SIZE;
|
||||
} else {
|
||||
/* Guest mapping is smaller than host page size. We must restrict the
|
||||
* size of the mapping to be at most the smaller of the two, but for
|
||||
* simplicity we fall back to a 4K mapping (this is probably what the
|
||||
* guest is using anyways). */
|
||||
stlbe.word0 |= (gvaddr & PAGE_MASK_4K) | PPC44x_TLB_4K;
|
||||
|
||||
/* 'hpaddr' is a host page, which is larger than the mapping we're
|
||||
* inserting here. To compensate, we must add the in-page offset to the
|
||||
* sub-page. */
|
||||
hpaddr |= gpaddr & (PAGE_MASK ^ PAGE_MASK_4K);
|
||||
}
|
||||
|
||||
stlbe.word1 = (hpaddr & 0xfffffc00) | ((hpaddr >> 32) & 0xf);
|
||||
stlbe.word2 = kvmppc_44x_tlb_shadow_attrib(flags,
|
||||
vcpu->arch.shared->msr & MSR_PR);
|
||||
stlbe.tid = !(asid & 0xff);
|
||||
|
||||
/* Keep track of the reference so we can properly release it later. */
|
||||
ref = &vcpu_44x->shadow_refs[victim];
|
||||
ref->page = new_page;
|
||||
ref->gtlb_index = gtlb_index;
|
||||
ref->writeable = !!(stlbe.word2 & PPC44x_TLB_UW);
|
||||
ref->tid = stlbe.tid;
|
||||
|
||||
/* Insert shadow mapping into hardware TLB. */
|
||||
kvmppc_44x_tlbe_set_modified(vcpu_44x, victim);
|
||||
kvmppc_44x_tlbwe(victim, &stlbe);
|
||||
trace_kvm_stlb_write(victim, stlbe.tid, stlbe.word0, stlbe.word1,
|
||||
stlbe.word2);
|
||||
}
|
||||
|
||||
/* For a particular guest TLB entry, invalidate the corresponding host TLB
|
||||
* mappings and release the host pages. */
|
||||
static void kvmppc_44x_invalidate(struct kvm_vcpu *vcpu,
|
||||
unsigned int gtlb_index)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(vcpu_44x->shadow_refs); i++) {
|
||||
struct kvmppc_44x_shadow_ref *ref = &vcpu_44x->shadow_refs[i];
|
||||
if (ref->gtlb_index == gtlb_index)
|
||||
kvmppc_44x_shadow_release(vcpu_44x, i);
|
||||
}
|
||||
}
|
||||
|
||||
void kvmppc_mmu_msr_notify(struct kvm_vcpu *vcpu, u32 old_msr)
|
||||
{
|
||||
int usermode = vcpu->arch.shared->msr & MSR_PR;
|
||||
|
||||
vcpu->arch.shadow_pid = !usermode;
|
||||
}
|
||||
|
||||
void kvmppc_set_pid(struct kvm_vcpu *vcpu, u32 new_pid)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
int i;
|
||||
|
||||
if (unlikely(vcpu->arch.pid == new_pid))
|
||||
return;
|
||||
|
||||
vcpu->arch.pid = new_pid;
|
||||
|
||||
/* Guest userspace runs with TID=0 mappings and PID=0, to make sure it
|
||||
* can't access guest kernel mappings (TID=1). When we switch to a new
|
||||
* guest PID, which will also use host PID=0, we must discard the old guest
|
||||
* userspace mappings. */
|
||||
for (i = 0; i < ARRAY_SIZE(vcpu_44x->shadow_refs); i++) {
|
||||
struct kvmppc_44x_shadow_ref *ref = &vcpu_44x->shadow_refs[i];
|
||||
|
||||
if (ref->tid == 0)
|
||||
kvmppc_44x_shadow_release(vcpu_44x, i);
|
||||
}
|
||||
}
|
||||
|
||||
static int tlbe_is_host_safe(const struct kvm_vcpu *vcpu,
|
||||
const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
gpa_t gpa;
|
||||
|
||||
if (!get_tlb_v(tlbe))
|
||||
return 0;
|
||||
|
||||
/* Does it match current guest AS? */
|
||||
/* XXX what about IS != DS? */
|
||||
if (get_tlb_ts(tlbe) != !!(vcpu->arch.shared->msr & MSR_IS))
|
||||
return 0;
|
||||
|
||||
gpa = get_tlb_raddr(tlbe);
|
||||
if (!gfn_to_memslot(vcpu->kvm, gpa >> PAGE_SHIFT))
|
||||
/* Mapping is not for RAM. */
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int kvmppc_44x_emul_tlbwe(struct kvm_vcpu *vcpu, u8 ra, u8 rs, u8 ws)
|
||||
{
|
||||
struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu);
|
||||
struct kvmppc_44x_tlbe *tlbe;
|
||||
unsigned int gtlb_index;
|
||||
int idx;
|
||||
|
||||
gtlb_index = kvmppc_get_gpr(vcpu, ra);
|
||||
if (gtlb_index >= KVM44x_GUEST_TLB_SIZE) {
|
||||
printk("%s: index %d\n", __func__, gtlb_index);
|
||||
kvmppc_dump_vcpu(vcpu);
|
||||
return EMULATE_FAIL;
|
||||
}
|
||||
|
||||
tlbe = &vcpu_44x->guest_tlb[gtlb_index];
|
||||
|
||||
/* Invalidate shadow mappings for the about-to-be-clobbered TLB entry. */
|
||||
if (tlbe->word0 & PPC44x_TLB_VALID)
|
||||
kvmppc_44x_invalidate(vcpu, gtlb_index);
|
||||
|
||||
switch (ws) {
|
||||
case PPC44x_TLB_PAGEID:
|
||||
tlbe->tid = get_mmucr_stid(vcpu);
|
||||
tlbe->word0 = kvmppc_get_gpr(vcpu, rs);
|
||||
break;
|
||||
|
||||
case PPC44x_TLB_XLAT:
|
||||
tlbe->word1 = kvmppc_get_gpr(vcpu, rs);
|
||||
break;
|
||||
|
||||
case PPC44x_TLB_ATTRIB:
|
||||
tlbe->word2 = kvmppc_get_gpr(vcpu, rs);
|
||||
break;
|
||||
|
||||
default:
|
||||
return EMULATE_FAIL;
|
||||
}
|
||||
|
||||
idx = srcu_read_lock(&vcpu->kvm->srcu);
|
||||
|
||||
if (tlbe_is_host_safe(vcpu, tlbe)) {
|
||||
gva_t eaddr;
|
||||
gpa_t gpaddr;
|
||||
u32 bytes;
|
||||
|
||||
eaddr = get_tlb_eaddr(tlbe);
|
||||
gpaddr = get_tlb_raddr(tlbe);
|
||||
|
||||
/* Use the advertised page size to mask effective and real addrs. */
|
||||
bytes = get_tlb_bytes(tlbe);
|
||||
eaddr &= ~(bytes - 1);
|
||||
gpaddr &= ~(bytes - 1);
|
||||
|
||||
kvmppc_mmu_map(vcpu, eaddr, gpaddr, gtlb_index);
|
||||
}
|
||||
|
||||
srcu_read_unlock(&vcpu->kvm->srcu, idx);
|
||||
|
||||
trace_kvm_gtlb_write(gtlb_index, tlbe->tid, tlbe->word0, tlbe->word1,
|
||||
tlbe->word2);
|
||||
|
||||
kvmppc_set_exit_type(vcpu, EMULATED_TLBWE_EXITS);
|
||||
return EMULATE_DONE;
|
||||
}
|
||||
|
||||
int kvmppc_44x_emul_tlbsx(struct kvm_vcpu *vcpu, u8 rt, u8 ra, u8 rb, u8 rc)
|
||||
{
|
||||
u32 ea;
|
||||
int gtlb_index;
|
||||
unsigned int as = get_mmucr_sts(vcpu);
|
||||
unsigned int pid = get_mmucr_stid(vcpu);
|
||||
|
||||
ea = kvmppc_get_gpr(vcpu, rb);
|
||||
if (ra)
|
||||
ea += kvmppc_get_gpr(vcpu, ra);
|
||||
|
||||
gtlb_index = kvmppc_44x_tlb_index(vcpu, ea, pid, as);
|
||||
if (rc) {
|
||||
u32 cr = kvmppc_get_cr(vcpu);
|
||||
|
||||
if (gtlb_index < 0)
|
||||
kvmppc_set_cr(vcpu, cr & ~0x20000000);
|
||||
else
|
||||
kvmppc_set_cr(vcpu, cr | 0x20000000);
|
||||
}
|
||||
kvmppc_set_gpr(vcpu, rt, gtlb_index);
|
||||
|
||||
kvmppc_set_exit_type(vcpu, EMULATED_TLBSX_EXITS);
|
||||
return EMULATE_DONE;
|
||||
}
|
@ -1,86 +0,0 @@
|
||||
/*
|
||||
* 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
|
||||
*
|
||||
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef __KVM_POWERPC_TLB_H__
|
||||
#define __KVM_POWERPC_TLB_H__
|
||||
|
||||
#include <linux/kvm_host.h>
|
||||
#include <asm/mmu-44x.h>
|
||||
|
||||
extern int kvmppc_44x_tlb_index(struct kvm_vcpu *vcpu, gva_t eaddr,
|
||||
unsigned int pid, unsigned int as);
|
||||
|
||||
extern int kvmppc_44x_emul_tlbsx(struct kvm_vcpu *vcpu, u8 rt, u8 ra, u8 rb,
|
||||
u8 rc);
|
||||
extern int kvmppc_44x_emul_tlbwe(struct kvm_vcpu *vcpu, u8 ra, u8 rs, u8 ws);
|
||||
|
||||
/* TLB helper functions */
|
||||
static inline unsigned int get_tlb_size(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return (tlbe->word0 >> 4) & 0xf;
|
||||
}
|
||||
|
||||
static inline gva_t get_tlb_eaddr(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return tlbe->word0 & 0xfffffc00;
|
||||
}
|
||||
|
||||
static inline gva_t get_tlb_bytes(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
unsigned int pgsize = get_tlb_size(tlbe);
|
||||
return 1 << 10 << (pgsize << 1);
|
||||
}
|
||||
|
||||
static inline gva_t get_tlb_end(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return get_tlb_eaddr(tlbe) + get_tlb_bytes(tlbe) - 1;
|
||||
}
|
||||
|
||||
static inline u64 get_tlb_raddr(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
u64 word1 = tlbe->word1;
|
||||
return ((word1 & 0xf) << 32) | (word1 & 0xfffffc00);
|
||||
}
|
||||
|
||||
static inline unsigned int get_tlb_tid(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return tlbe->tid & 0xff;
|
||||
}
|
||||
|
||||
static inline unsigned int get_tlb_ts(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return (tlbe->word0 >> 8) & 0x1;
|
||||
}
|
||||
|
||||
static inline unsigned int get_tlb_v(const struct kvmppc_44x_tlbe *tlbe)
|
||||
{
|
||||
return (tlbe->word0 >> 9) & 0x1;
|
||||
}
|
||||
|
||||
static inline unsigned int get_mmucr_stid(const struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return vcpu->arch.mmucr & 0xff;
|
||||
}
|
||||
|
||||
static inline unsigned int get_mmucr_sts(const struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return (vcpu->arch.mmucr >> 16) & 0x1;
|
||||
}
|
||||
|
||||
#endif /* __KVM_POWERPC_TLB_H__ */
|
@ -112,23 +112,9 @@ config KVM_BOOK3S_64_PR
|
||||
config KVM_BOOKE_HV
|
||||
bool
|
||||
|
||||
config KVM_440
|
||||
bool "KVM support for PowerPC 440 processors"
|
||||
depends on 44x
|
||||
select KVM
|
||||
select KVM_MMIO
|
||||
---help---
|
||||
Support running unmodified 440 guest kernels in virtual machines on
|
||||
440 host processors.
|
||||
|
||||
This module provides access to the hardware capabilities through
|
||||
a character device node named /dev/kvm.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
config KVM_EXIT_TIMING
|
||||
bool "Detailed exit timing"
|
||||
depends on KVM_440 || KVM_E500V2 || KVM_E500MC
|
||||
depends on KVM_E500V2 || KVM_E500MC
|
||||
---help---
|
||||
Calculate elapsed time for every exit/enter cycle. A per-vcpu
|
||||
report is available in debugfs kvm/vm#_vcpu#_timing.
|
||||
|
@ -10,7 +10,6 @@ KVM := ../../../virt/kvm
|
||||
common-objs-y = $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o \
|
||||
$(KVM)/eventfd.o
|
||||
|
||||
CFLAGS_44x_tlb.o := -I.
|
||||
CFLAGS_e500_mmu.o := -I.
|
||||
CFLAGS_e500_mmu_host.o := -I.
|
||||
CFLAGS_emulate.o := -I.
|
||||
@ -21,16 +20,6 @@ obj-$(CONFIG_KVM_BOOK3S_HANDLER) += book3s_exports.o
|
||||
|
||||
AFLAGS_booke_interrupts.o := -I$(obj)
|
||||
|
||||
kvm-440-objs := \
|
||||
$(common-objs-y) \
|
||||
booke.o \
|
||||
booke_emulate.o \
|
||||
booke_interrupts.o \
|
||||
44x.o \
|
||||
44x_tlb.o \
|
||||
44x_emulate.o
|
||||
kvm-objs-$(CONFIG_KVM_440) := $(kvm-440-objs)
|
||||
|
||||
kvm-e500-objs := \
|
||||
$(common-objs-y) \
|
||||
booke.o \
|
||||
@ -127,7 +116,6 @@ kvm-objs-$(CONFIG_HAVE_KVM_IRQ_ROUTING) += $(KVM)/irqchip.o
|
||||
|
||||
kvm-objs := $(kvm-objs-m) $(kvm-objs-y)
|
||||
|
||||
obj-$(CONFIG_KVM_440) += kvm.o
|
||||
obj-$(CONFIG_KVM_E500V2) += kvm.o
|
||||
obj-$(CONFIG_KVM_E500MC) += kvm.o
|
||||
obj-$(CONFIG_KVM_BOOK3S_64) += kvm.o
|
||||
|
@ -99,13 +99,6 @@ enum int_class {
|
||||
|
||||
void kvmppc_set_pending_interrupt(struct kvm_vcpu *vcpu, enum int_class type);
|
||||
|
||||
extern void kvmppc_mmu_destroy_44x(struct kvm_vcpu *vcpu);
|
||||
extern int kvmppc_core_emulate_op_44x(struct kvm_run *run, struct kvm_vcpu *vcpu,
|
||||
unsigned int inst, int *advance);
|
||||
extern int kvmppc_core_emulate_mtspr_44x(struct kvm_vcpu *vcpu, int sprn,
|
||||
ulong spr_val);
|
||||
extern int kvmppc_core_emulate_mfspr_44x(struct kvm_vcpu *vcpu, int sprn,
|
||||
ulong *spr_val);
|
||||
extern void kvmppc_mmu_destroy_e500(struct kvm_vcpu *vcpu);
|
||||
extern int kvmppc_core_emulate_op_e500(struct kvm_run *run,
|
||||
struct kvm_vcpu *vcpu,
|
||||
|
@ -21,7 +21,6 @@
|
||||
#include <asm/ppc_asm.h>
|
||||
#include <asm/kvm_asm.h>
|
||||
#include <asm/reg.h>
|
||||
#include <asm/mmu-44x.h>
|
||||
#include <asm/page.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
|
||||
@ -424,10 +423,6 @@ lightweight_exit:
|
||||
mtspr SPRN_PID1, r3
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_44x
|
||||
iccci 0, 0 /* XXX hack */
|
||||
#endif
|
||||
|
||||
/* Load some guest volatiles. */
|
||||
lwz r0, VCPU_GPR(R0)(r4)
|
||||
lwz r2, VCPU_GPR(R2)(r4)
|
||||
|
@ -24,7 +24,6 @@
|
||||
#include <asm/ppc_asm.h>
|
||||
#include <asm/kvm_asm.h>
|
||||
#include <asm/reg.h>
|
||||
#include <asm/mmu-44x.h>
|
||||
#include <asm/page.h>
|
||||
#include <asm/asm-compat.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
|
@ -217,7 +217,6 @@ int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
|
||||
case KVM_HCALL_TOKEN(KVM_HC_FEATURES):
|
||||
r = EV_SUCCESS;
|
||||
#if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2)
|
||||
/* XXX Missing magic page on 44x */
|
||||
r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
|
||||
#endif
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user