969391c58a
This replaces the single CPU_FTR_HVMODE_206 bit with two bits, one to indicate that we have a usable hypervisor mode, and another to indicate that the processor conforms to PowerISA version 2.06. We also add another bit to indicate that the processor conforms to ISA version 2.01 and set that for PPC970 and derivatives. Some PPC970 chips (specifically those in Apple machines) have a hypervisor mode in that MSR[HV] is always 1, but the hypervisor mode is not useful in the sense that there is no way to run any code in supervisor mode (HV=0 PR=0). On these processors, the LPES0 and LPES1 bits in HID4 are always 0, and we use that as a way of detecting that hypervisor mode is not useful. Where we have a feature section in assembly code around code that only applies on POWER7 in hypervisor mode, we use a construct like END_FTR_SECTION_IFSET(CPU_FTR_HVMODE | CPU_FTR_ARCH_206) The definition of END_FTR_SECTION_IFSET is such that the code will be enabled (not overwritten with nops) only if all bits in the provided mask are set. Note that the CPU feature check in __tlbie() only needs to check the ARCH_206 bit, not the HVMODE bit, because __tlbie() can only get called if we are running bare-metal, i.e. in hypervisor mode. Signed-off-by: Paul Mackerras <paulus@samba.org> Signed-off-by: Alexander Graf <agraf@suse.de>
153 lines
3.6 KiB
C
153 lines
3.6 KiB
C
/*
|
|
* Copyright 2011 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/preempt.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/bootmem.h>
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/cputable.h>
|
|
#include <asm/kvm_ppc.h>
|
|
#include <asm/kvm_book3s.h>
|
|
|
|
/*
|
|
* This maintains a list of RMAs (real mode areas) for KVM guests to use.
|
|
* Each RMA has to be physically contiguous and of a size that the
|
|
* hardware supports. PPC970 and POWER7 support 64MB, 128MB and 256MB,
|
|
* and other larger sizes. Since we are unlikely to be allocate that
|
|
* much physically contiguous memory after the system is up and running,
|
|
* we preallocate a set of RMAs in early boot for KVM to use.
|
|
*/
|
|
static unsigned long kvm_rma_size = 64 << 20; /* 64MB */
|
|
static unsigned long kvm_rma_count;
|
|
|
|
static int __init early_parse_rma_size(char *p)
|
|
{
|
|
if (!p)
|
|
return 1;
|
|
|
|
kvm_rma_size = memparse(p, &p);
|
|
|
|
return 0;
|
|
}
|
|
early_param("kvm_rma_size", early_parse_rma_size);
|
|
|
|
static int __init early_parse_rma_count(char *p)
|
|
{
|
|
if (!p)
|
|
return 1;
|
|
|
|
kvm_rma_count = simple_strtoul(p, NULL, 0);
|
|
|
|
return 0;
|
|
}
|
|
early_param("kvm_rma_count", early_parse_rma_count);
|
|
|
|
static struct kvmppc_rma_info *rma_info;
|
|
static LIST_HEAD(free_rmas);
|
|
static DEFINE_SPINLOCK(rma_lock);
|
|
|
|
/* Work out RMLS (real mode limit selector) field value for a given RMA size.
|
|
Assumes POWER7. */
|
|
static inline int lpcr_rmls(unsigned long rma_size)
|
|
{
|
|
switch (rma_size) {
|
|
case 32ul << 20: /* 32 MB */
|
|
return 8;
|
|
case 64ul << 20: /* 64 MB */
|
|
return 3;
|
|
case 128ul << 20: /* 128 MB */
|
|
return 7;
|
|
case 256ul << 20: /* 256 MB */
|
|
return 4;
|
|
case 1ul << 30: /* 1 GB */
|
|
return 2;
|
|
case 16ul << 30: /* 16 GB */
|
|
return 1;
|
|
case 256ul << 30: /* 256 GB */
|
|
return 0;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called at boot time while the bootmem allocator is active,
|
|
* to allocate contiguous physical memory for the real memory
|
|
* areas for guests.
|
|
*/
|
|
void kvm_rma_init(void)
|
|
{
|
|
unsigned long i;
|
|
unsigned long j, npages;
|
|
void *rma;
|
|
struct page *pg;
|
|
|
|
/* Only do this in HV mode */
|
|
if (!cpu_has_feature(CPU_FTR_HVMODE))
|
|
return;
|
|
|
|
if (!kvm_rma_size || !kvm_rma_count)
|
|
return;
|
|
|
|
/* Check that the requested size is one supported in hardware */
|
|
if (lpcr_rmls(kvm_rma_size) < 0) {
|
|
pr_err("RMA size of 0x%lx not supported\n", kvm_rma_size);
|
|
return;
|
|
}
|
|
|
|
npages = kvm_rma_size >> PAGE_SHIFT;
|
|
rma_info = alloc_bootmem(kvm_rma_count * sizeof(struct kvmppc_rma_info));
|
|
for (i = 0; i < kvm_rma_count; ++i) {
|
|
rma = alloc_bootmem_align(kvm_rma_size, kvm_rma_size);
|
|
pr_info("Allocated KVM RMA at %p (%ld MB)\n", rma,
|
|
kvm_rma_size >> 20);
|
|
rma_info[i].base_virt = rma;
|
|
rma_info[i].base_pfn = __pa(rma) >> PAGE_SHIFT;
|
|
rma_info[i].npages = npages;
|
|
list_add_tail(&rma_info[i].list, &free_rmas);
|
|
atomic_set(&rma_info[i].use_count, 0);
|
|
|
|
pg = pfn_to_page(rma_info[i].base_pfn);
|
|
for (j = 0; j < npages; ++j) {
|
|
atomic_inc(&pg->_count);
|
|
++pg;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct kvmppc_rma_info *kvm_alloc_rma(void)
|
|
{
|
|
struct kvmppc_rma_info *ri;
|
|
|
|
ri = NULL;
|
|
spin_lock(&rma_lock);
|
|
if (!list_empty(&free_rmas)) {
|
|
ri = list_first_entry(&free_rmas, struct kvmppc_rma_info, list);
|
|
list_del(&ri->list);
|
|
atomic_inc(&ri->use_count);
|
|
}
|
|
spin_unlock(&rma_lock);
|
|
return ri;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_alloc_rma);
|
|
|
|
void kvm_release_rma(struct kvmppc_rma_info *ri)
|
|
{
|
|
if (atomic_dec_and_test(&ri->use_count)) {
|
|
spin_lock(&rma_lock);
|
|
list_add_tail(&ri->list, &free_rmas);
|
|
spin_unlock(&rma_lock);
|
|
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_release_rma);
|
|
|