mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 11:16:40 +07:00
b4deba5c41
This builds on the ability to run more than one vcore on a physical core by using the micro-threading (split-core) modes of the POWER8 chip. Previously, only vcores from the same VM could be run together, and (on POWER8) only if they had just one thread per core. With the ability to split the core on guest entry and unsplit it on guest exit, we can run up to 8 vcpu threads from up to 4 different VMs, and we can run multiple vcores with 2 or 4 vcpus per vcore. Dynamic micro-threading is only available if the static configuration of the cores is whole-core mode (unsplit), and only on POWER8. To manage this, we introduce a new kvm_split_mode struct which is shared across all of the subcores in the core, with a pointer in the paca on each thread. In addition we extend the core_info struct to have information on each subcore. When deciding whether to add a vcore to the set already on the core, we now have two possibilities: (a) piggyback the vcore onto an existing subcore, or (b) start a new subcore. Currently, when any vcpu needs to exit the guest and switch to host virtual mode, we interrupt all the threads in all subcores and switch the core back to whole-core mode. It may be possible in future to allow some of the subcores to keep executing in the guest while subcore 0 switches to the host, but that is not implemented in this patch. This adds a module parameter called dynamic_mt_modes which controls which micro-threading (split-core) modes the code will consider, as a bitmap. In other words, if it is 0, no micro-threading mode is considered; if it is 2, only 2-way micro-threading is considered; if it is 4, only 4-way, and if it is 6, both 2-way and 4-way micro-threading mode will be considered. The default is 6. With this, we now have secondary threads which are the primary thread for their subcore and therefore need to do the MMU switch. These threads will need to be started even if they have no vcpu to run, so we use the vcore pointer in the PACA rather than the vcpu pointer to trigger them. It is now possible for thread 0 to find that an exit has been requested before it gets to switch the subcore state to the guest. In that case we haven't added the guest's timebase offset to the timebase, so we need to be careful not to subtract the offset in the guest exit path. In fact we just skip the whole path that switches back to host context, since we haven't switched to the guest context. Signed-off-by: Paul Mackerras <paulus@samba.org> Signed-off-by: Alexander Graf <agraf@suse.de>
286 lines
7.3 KiB
C
286 lines
7.3 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/cpu.h>
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/preempt.h>
|
|
#include <linux/export.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/init.h>
|
|
#include <linux/memblock.h>
|
|
#include <linux/sizes.h>
|
|
#include <linux/cma.h>
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/cputable.h>
|
|
#include <asm/kvm_ppc.h>
|
|
#include <asm/kvm_book3s.h>
|
|
#include <asm/archrandom.h>
|
|
#include <asm/xics.h>
|
|
#include <asm/dbell.h>
|
|
#include <asm/cputhreads.h>
|
|
|
|
#define KVM_CMA_CHUNK_ORDER 18
|
|
|
|
/*
|
|
* Hash page table alignment on newer cpus(CPU_FTR_ARCH_206)
|
|
* should be power of 2.
|
|
*/
|
|
#define HPT_ALIGN_PAGES ((1 << 18) >> PAGE_SHIFT) /* 256k */
|
|
/*
|
|
* By default we reserve 5% of memory for hash pagetable allocation.
|
|
*/
|
|
static unsigned long kvm_cma_resv_ratio = 5;
|
|
|
|
static struct cma *kvm_cma;
|
|
|
|
static int __init early_parse_kvm_cma_resv(char *p)
|
|
{
|
|
pr_debug("%s(%s)\n", __func__, p);
|
|
if (!p)
|
|
return -EINVAL;
|
|
return kstrtoul(p, 0, &kvm_cma_resv_ratio);
|
|
}
|
|
early_param("kvm_cma_resv_ratio", early_parse_kvm_cma_resv);
|
|
|
|
struct page *kvm_alloc_hpt(unsigned long nr_pages)
|
|
{
|
|
VM_BUG_ON(order_base_2(nr_pages) < KVM_CMA_CHUNK_ORDER - PAGE_SHIFT);
|
|
|
|
return cma_alloc(kvm_cma, nr_pages, order_base_2(HPT_ALIGN_PAGES));
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_alloc_hpt);
|
|
|
|
void kvm_release_hpt(struct page *page, unsigned long nr_pages)
|
|
{
|
|
cma_release(kvm_cma, page, nr_pages);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_release_hpt);
|
|
|
|
/**
|
|
* kvm_cma_reserve() - reserve area for kvm hash pagetable
|
|
*
|
|
* This function reserves memory from early allocator. It should be
|
|
* called by arch specific code once the memblock allocator
|
|
* has been activated and all other subsystems have already allocated/reserved
|
|
* memory.
|
|
*/
|
|
void __init kvm_cma_reserve(void)
|
|
{
|
|
unsigned long align_size;
|
|
struct memblock_region *reg;
|
|
phys_addr_t selected_size = 0;
|
|
|
|
/*
|
|
* We need CMA reservation only when we are in HV mode
|
|
*/
|
|
if (!cpu_has_feature(CPU_FTR_HVMODE))
|
|
return;
|
|
/*
|
|
* We cannot use memblock_phys_mem_size() here, because
|
|
* memblock_analyze() has not been called yet.
|
|
*/
|
|
for_each_memblock(memory, reg)
|
|
selected_size += memblock_region_memory_end_pfn(reg) -
|
|
memblock_region_memory_base_pfn(reg);
|
|
|
|
selected_size = (selected_size * kvm_cma_resv_ratio / 100) << PAGE_SHIFT;
|
|
if (selected_size) {
|
|
pr_debug("%s: reserving %ld MiB for global area\n", __func__,
|
|
(unsigned long)selected_size / SZ_1M);
|
|
align_size = HPT_ALIGN_PAGES << PAGE_SHIFT;
|
|
cma_declare_contiguous(0, selected_size, 0, align_size,
|
|
KVM_CMA_CHUNK_ORDER - PAGE_SHIFT, false, &kvm_cma);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Real-mode H_CONFER implementation.
|
|
* We check if we are the only vcpu out of this virtual core
|
|
* still running in the guest and not ceded. If so, we pop up
|
|
* to the virtual-mode implementation; if not, just return to
|
|
* the guest.
|
|
*/
|
|
long int kvmppc_rm_h_confer(struct kvm_vcpu *vcpu, int target,
|
|
unsigned int yield_count)
|
|
{
|
|
struct kvmppc_vcore *vc = local_paca->kvm_hstate.kvm_vcore;
|
|
int ptid = local_paca->kvm_hstate.ptid;
|
|
int threads_running;
|
|
int threads_ceded;
|
|
int threads_conferring;
|
|
u64 stop = get_tb() + 10 * tb_ticks_per_usec;
|
|
int rv = H_SUCCESS; /* => don't yield */
|
|
|
|
set_bit(ptid, &vc->conferring_threads);
|
|
while ((get_tb() < stop) && !VCORE_IS_EXITING(vc)) {
|
|
threads_running = VCORE_ENTRY_MAP(vc);
|
|
threads_ceded = vc->napping_threads;
|
|
threads_conferring = vc->conferring_threads;
|
|
if ((threads_ceded | threads_conferring) == threads_running) {
|
|
rv = H_TOO_HARD; /* => do yield */
|
|
break;
|
|
}
|
|
}
|
|
clear_bit(ptid, &vc->conferring_threads);
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* When running HV mode KVM we need to block certain operations while KVM VMs
|
|
* exist in the system. We use a counter of VMs to track this.
|
|
*
|
|
* One of the operations we need to block is onlining of secondaries, so we
|
|
* protect hv_vm_count with get/put_online_cpus().
|
|
*/
|
|
static atomic_t hv_vm_count;
|
|
|
|
void kvm_hv_vm_activated(void)
|
|
{
|
|
get_online_cpus();
|
|
atomic_inc(&hv_vm_count);
|
|
put_online_cpus();
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_hv_vm_activated);
|
|
|
|
void kvm_hv_vm_deactivated(void)
|
|
{
|
|
get_online_cpus();
|
|
atomic_dec(&hv_vm_count);
|
|
put_online_cpus();
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_hv_vm_deactivated);
|
|
|
|
bool kvm_hv_mode_active(void)
|
|
{
|
|
return atomic_read(&hv_vm_count) != 0;
|
|
}
|
|
|
|
extern int hcall_real_table[], hcall_real_table_end[];
|
|
|
|
int kvmppc_hcall_impl_hv_realmode(unsigned long cmd)
|
|
{
|
|
cmd /= 4;
|
|
if (cmd < hcall_real_table_end - hcall_real_table &&
|
|
hcall_real_table[cmd])
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvmppc_hcall_impl_hv_realmode);
|
|
|
|
int kvmppc_hwrng_present(void)
|
|
{
|
|
return powernv_hwrng_present();
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvmppc_hwrng_present);
|
|
|
|
long kvmppc_h_random(struct kvm_vcpu *vcpu)
|
|
{
|
|
if (powernv_get_random_real_mode(&vcpu->arch.gpr[4]))
|
|
return H_SUCCESS;
|
|
|
|
return H_HARDWARE;
|
|
}
|
|
|
|
static inline void rm_writeb(unsigned long paddr, u8 val)
|
|
{
|
|
__asm__ __volatile__("stbcix %0,0,%1"
|
|
: : "r" (val), "r" (paddr) : "memory");
|
|
}
|
|
|
|
/*
|
|
* Send an interrupt or message to another CPU.
|
|
* This can only be called in real mode.
|
|
* The caller needs to include any barrier needed to order writes
|
|
* to memory vs. the IPI/message.
|
|
*/
|
|
void kvmhv_rm_send_ipi(int cpu)
|
|
{
|
|
unsigned long xics_phys;
|
|
|
|
/* On POWER8 for IPIs to threads in the same core, use msgsnd */
|
|
if (cpu_has_feature(CPU_FTR_ARCH_207S) &&
|
|
cpu_first_thread_sibling(cpu) ==
|
|
cpu_first_thread_sibling(raw_smp_processor_id())) {
|
|
unsigned long msg = PPC_DBELL_TYPE(PPC_DBELL_SERVER);
|
|
msg |= cpu_thread_in_core(cpu);
|
|
__asm__ __volatile__ (PPC_MSGSND(%0) : : "r" (msg));
|
|
return;
|
|
}
|
|
|
|
/* Else poke the target with an IPI */
|
|
xics_phys = paca[cpu].kvm_hstate.xics_phys;
|
|
rm_writeb(xics_phys + XICS_MFRR, IPI_PRIORITY);
|
|
}
|
|
|
|
/*
|
|
* The following functions are called from the assembly code
|
|
* in book3s_hv_rmhandlers.S.
|
|
*/
|
|
static void kvmhv_interrupt_vcore(struct kvmppc_vcore *vc, int active)
|
|
{
|
|
int cpu = vc->pcpu;
|
|
|
|
/* Order setting of exit map vs. msgsnd/IPI */
|
|
smp_mb();
|
|
for (; active; active >>= 1, ++cpu)
|
|
if (active & 1)
|
|
kvmhv_rm_send_ipi(cpu);
|
|
}
|
|
|
|
void kvmhv_commence_exit(int trap)
|
|
{
|
|
struct kvmppc_vcore *vc = local_paca->kvm_hstate.kvm_vcore;
|
|
int ptid = local_paca->kvm_hstate.ptid;
|
|
struct kvm_split_mode *sip = local_paca->kvm_hstate.kvm_split_mode;
|
|
int me, ee, i;
|
|
|
|
/* Set our bit in the threads-exiting-guest map in the 0xff00
|
|
bits of vcore->entry_exit_map */
|
|
me = 0x100 << ptid;
|
|
do {
|
|
ee = vc->entry_exit_map;
|
|
} while (cmpxchg(&vc->entry_exit_map, ee, ee | me) != ee);
|
|
|
|
/* Are we the first here? */
|
|
if ((ee >> 8) != 0)
|
|
return;
|
|
|
|
/*
|
|
* Trigger the other threads in this vcore to exit the guest.
|
|
* If this is a hypervisor decrementer interrupt then they
|
|
* will be already on their way out of the guest.
|
|
*/
|
|
if (trap != BOOK3S_INTERRUPT_HV_DECREMENTER)
|
|
kvmhv_interrupt_vcore(vc, ee & ~(1 << ptid));
|
|
|
|
/*
|
|
* If we are doing dynamic micro-threading, interrupt the other
|
|
* subcores to pull them out of their guests too.
|
|
*/
|
|
if (!sip)
|
|
return;
|
|
|
|
for (i = 0; i < MAX_SUBCORES; ++i) {
|
|
vc = sip->master_vcs[i];
|
|
if (!vc)
|
|
break;
|
|
do {
|
|
ee = vc->entry_exit_map;
|
|
/* Already asked to exit? */
|
|
if ((ee >> 8) != 0)
|
|
break;
|
|
} while (cmpxchg(&vc->entry_exit_map, ee,
|
|
ee | VCORE_EXIT_REQ) != ee);
|
|
if ((ee >> 8) == 0)
|
|
kvmhv_interrupt_vcore(vc, ee);
|
|
}
|
|
}
|