[mirror_ubuntu-artful-kernel.git] / arch / powerpc / kvm / book3s_64_mmu_hv.c

/*
 * 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 2010 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
 */

#include <linux/types.h>
#include <linux/string.h>
#include <linux/kvm.h>
#include <linux/kvm_host.h>
#include <linux/highmem.h>
#include <linux/gfp.h>
#include <linux/slab.h>
#include <linux/hugetlb.h>
#include <linux/vmalloc.h>

#include <asm/tlbflush.h>
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s.h>
#include <asm/mmu-hash64.h>
#include <asm/hvcall.h>
#include <asm/synch.h>
#include <asm/ppc-opcode.h>
#include <asm/cputable.h>

#define VRMA_VSID	0x1ffffffUL	/* 1TB VSID reserved for VRMA */

/* POWER7 has 10-bit LPIDs, PPC970 has 6-bit LPIDs */
#define MAX_LPID_970	63
#define NR_LPIDS	(LPID_RSVD + 1)
unsigned long lpid_inuse[BITS_TO_LONGS(NR_LPIDS)];

long kvmppc_alloc_hpt(struct kvm *kvm)
{
	unsigned long hpt;
	unsigned long lpid;
	struct revmap_entry *rev;

	/* Allocate guest's hashed page table */
	hpt = __get_free_pages(GFP_KERNEL|__GFP_ZERO|__GFP_REPEAT|__GFP_NOWARN,
			       HPT_ORDER - PAGE_SHIFT);
	if (!hpt) {
		pr_err("kvm_alloc_hpt: Couldn't alloc HPT\n");
		return -ENOMEM;
	}
	kvm->arch.hpt_virt = hpt;

	/* Allocate reverse map array */
	rev = vmalloc(sizeof(struct revmap_entry) * HPT_NPTE);
	if (!rev) {
		pr_err("kvmppc_alloc_hpt: Couldn't alloc reverse map array\n");
		goto out_freehpt;
	}
	kvm->arch.revmap = rev;

	/* Allocate the guest's logical partition ID */
	do {
		lpid = find_first_zero_bit(lpid_inuse, NR_LPIDS);
		if (lpid >= NR_LPIDS) {
			pr_err("kvm_alloc_hpt: No LPIDs free\n");
			goto out_freeboth;
		}
	} while (test_and_set_bit(lpid, lpid_inuse));

	kvm->arch.sdr1 = __pa(hpt) | (HPT_ORDER - 18);
	kvm->arch.lpid = lpid;

	pr_info("KVM guest htab at %lx, LPID %lx\n", hpt, lpid);
	return 0;

 out_freeboth:
	vfree(rev);
 out_freehpt:
	free_pages(hpt, HPT_ORDER - PAGE_SHIFT);
	return -ENOMEM;
}

void kvmppc_free_hpt(struct kvm *kvm)
{
	clear_bit(kvm->arch.lpid, lpid_inuse);
	vfree(kvm->arch.revmap);
	free_pages(kvm->arch.hpt_virt, HPT_ORDER - PAGE_SHIFT);
}

/* Bits in first HPTE dword for pagesize 4k, 64k or 16M */
static inline unsigned long hpte0_pgsize_encoding(unsigned long pgsize)
{
	return (pgsize > 0x1000) ? HPTE_V_LARGE : 0;
}

/* Bits in second HPTE dword for pagesize 4k, 64k or 16M */
static inline unsigned long hpte1_pgsize_encoding(unsigned long pgsize)
{
	return (pgsize == 0x10000) ? 0x1000 : 0;
}

void kvmppc_map_vrma(struct kvm_vcpu *vcpu, struct kvm_memory_slot *memslot,
		     unsigned long porder)
{
	unsigned long i;
	unsigned long npages;
	unsigned long hp_v, hp_r;
	unsigned long addr, hash;
	unsigned long psize;
	unsigned long hp0, hp1;
	long ret;

	psize = 1ul << porder;
	npages = memslot->npages >> (porder - PAGE_SHIFT);

	/* VRMA can't be > 1TB */
	if (npages > 1ul << (40 - porder))
		npages = 1ul << (40 - porder);
	/* Can't use more than 1 HPTE per HPTEG */
	if (npages > HPT_NPTEG)
		npages = HPT_NPTEG;

	hp0 = HPTE_V_1TB_SEG | (VRMA_VSID << (40 - 16)) |
		HPTE_V_BOLTED | hpte0_pgsize_encoding(psize);
	hp1 = hpte1_pgsize_encoding(psize) |
		HPTE_R_R | HPTE_R_C | HPTE_R_M | PP_RWXX;

	for (i = 0; i < npages; ++i) {
		addr = i << porder;
		/* can't use hpt_hash since va > 64 bits */
		hash = (i ^ (VRMA_VSID ^ (VRMA_VSID << 25))) & HPT_HASH_MASK;
		/*
		 * We assume that the hash table is empty and no
		 * vcpus are using it at this stage.  Since we create
		 * at most one HPTE per HPTEG, we just assume entry 7
		 * is available and use it.
		 */
		hash = (hash << 3) + 7;
		hp_v = hp0 | ((addr >> 16) & ~0x7fUL);
		hp_r = hp1 | addr;
		ret = kvmppc_virtmode_h_enter(vcpu, H_EXACT, hash, hp_v, hp_r);
		if (ret != H_SUCCESS) {
			pr_err("KVM: map_vrma at %lx failed, ret=%ld\n",
			       addr, ret);
			break;
		}
	}
}

int kvmppc_mmu_hv_init(void)
{
	unsigned long host_lpid, rsvd_lpid;

	if (!cpu_has_feature(CPU_FTR_HVMODE))
		return -EINVAL;

	memset(lpid_inuse, 0, sizeof(lpid_inuse));

	if (cpu_has_feature(CPU_FTR_ARCH_206)) {
		host_lpid = mfspr(SPRN_LPID);	/* POWER7 */
		rsvd_lpid = LPID_RSVD;
	} else {
		host_lpid = 0;			/* PPC970 */
		rsvd_lpid = MAX_LPID_970;
	}

	set_bit(host_lpid, lpid_inuse);
	/* rsvd_lpid is reserved for use in partition switching */
	set_bit(rsvd_lpid, lpid_inuse);

	return 0;
}

void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu)
{
}

static void kvmppc_mmu_book3s_64_hv_reset_msr(struct kvm_vcpu *vcpu)
{
	kvmppc_set_msr(vcpu, MSR_SF | MSR_ME);
}

/*
 * This is called to get a reference to a guest page if there isn't
 * one already in the kvm->arch.slot_phys[][] arrays.
 */
static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
				  struct kvm_memory_slot *memslot,
				  unsigned long psize)
{
	unsigned long start;
	long np, err;
	struct page *page, *hpage, *pages[1];
	unsigned long s, pgsize;
	unsigned long *physp;
	unsigned int got, pgorder;
	unsigned long pfn, i, npages;

	physp = kvm->arch.slot_phys[memslot->id];
	if (!physp)
		return -EINVAL;
	if (physp[gfn - memslot->base_gfn])
		return 0;

	page = NULL;
	pgsize = psize;
	start = gfn_to_hva_memslot(memslot, gfn);

	/* Instantiate and get the page we want access to */
	np = get_user_pages_fast(start, 1, 1, pages);
	if (np != 1)
		return -EINVAL;
	page = pages[0];
	got = KVMPPC_GOT_PAGE;

	/* See if this is a large page */
	s = PAGE_SIZE;
	if (PageHuge(page)) {
		hpage = compound_head(page);
		s <<= compound_order(hpage);
		/* Get the whole large page if slot alignment is ok */
		if (s > psize && slot_is_aligned(memslot, s) &&
		    !(memslot->userspace_addr & (s - 1))) {
			start &= ~(s - 1);
			pgsize = s;
			page = hpage;
		}
	}
	err = -EINVAL;
	if (s < psize)
		goto out;
	pfn = page_to_pfn(page);

	npages = pgsize >> PAGE_SHIFT;
	pgorder = __ilog2(npages);
	physp += (gfn - memslot->base_gfn) & ~(npages - 1);
	spin_lock(&kvm->arch.slot_phys_lock);
	for (i = 0; i < npages; ++i) {
		if (!physp[i]) {
			physp[i] = ((pfn + i) << PAGE_SHIFT) + got + pgorder;
			got = 0;
		}
	}
	spin_unlock(&kvm->arch.slot_phys_lock);
	err = 0;

 out:
	if (got) {
		if (PageHuge(page))
			page = compound_head(page);
		put_page(page);
	}
	return err;
}

/*
 * We come here on a H_ENTER call from the guest when
 * we don't have the requested page pinned already.
 */
long kvmppc_virtmode_h_enter(struct kvm_vcpu *vcpu, unsigned long flags,
			long pte_index, unsigned long pteh, unsigned long ptel)
{
	struct kvm *kvm = vcpu->kvm;
	unsigned long psize, gpa, gfn;
	struct kvm_memory_slot *memslot;
	long ret;

	psize = hpte_page_size(pteh, ptel);
	if (!psize)
		return H_PARAMETER;

	/* Find the memslot (if any) for this address */
	gpa = (ptel & HPTE_R_RPN) & ~(psize - 1);
	gfn = gpa >> PAGE_SHIFT;
	memslot = gfn_to_memslot(kvm, gfn);
	if (!memslot || (memslot->flags & KVM_MEMSLOT_INVALID))
		return H_PARAMETER;
	if (!slot_is_aligned(memslot, psize))
		return H_PARAMETER;
	if (kvmppc_get_guest_page(kvm, gfn, memslot, psize) < 0)
		return H_PARAMETER;

	preempt_disable();
	ret = kvmppc_h_enter(vcpu, flags, pte_index, pteh, ptel);
	preempt_enable();
	if (ret == H_TOO_HARD) {
		/* this can't happen */
		pr_err("KVM: Oops, kvmppc_h_enter returned too hard!\n");
		ret = H_RESOURCE;	/* or something */
	}
	return ret;

}

static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
				struct kvmppc_pte *gpte, bool data)
{
	return -ENOENT;
}

void *kvmppc_pin_guest_page(struct kvm *kvm, unsigned long gpa,
			    unsigned long *nb_ret)
{
	struct kvm_memory_slot *memslot;
	unsigned long gfn = gpa >> PAGE_SHIFT;
	struct page *page;
	unsigned long psize, offset;
	unsigned long pa;
	unsigned long *physp;

	memslot = gfn_to_memslot(kvm, gfn);
	if (!memslot || (memslot->flags & KVM_MEMSLOT_INVALID))
		return NULL;
	physp = kvm->arch.slot_phys[memslot->id];
	if (!physp)
		return NULL;
	physp += gfn - memslot->base_gfn;
	pa = *physp;
	if (!pa) {
		if (kvmppc_get_guest_page(kvm, gfn, memslot, PAGE_SIZE) < 0)
			return NULL;
		pa = *physp;
	}
	page = pfn_to_page(pa >> PAGE_SHIFT);
	psize = PAGE_SIZE;
	if (PageHuge(page)) {
		page = compound_head(page);
		psize <<= compound_order(page);
	}
	get_page(page);
	offset = gpa & (psize - 1);
	if (nb_ret)
		*nb_ret = psize - offset;
	return page_address(page) + offset;
}

void kvmppc_unpin_guest_page(struct kvm *kvm, void *va)
{
	struct page *page = virt_to_page(va);

	page = compound_head(page);
	put_page(page);
}

void kvmppc_mmu_book3s_hv_init(struct kvm_vcpu *vcpu)
{
	struct kvmppc_mmu *mmu = &vcpu->arch.mmu;

	if (cpu_has_feature(CPU_FTR_ARCH_206))
		vcpu->arch.slb_nr = 32;		/* POWER7 */
	else
		vcpu->arch.slb_nr = 64;

	mmu->xlate = kvmppc_mmu_book3s_64_hv_xlate;
	mmu->reset_msr = kvmppc_mmu_book3s_64_hv_reset_msr;

	vcpu->arch.hflags |= BOOK3S_HFLAG_SLB;
}
Commit	Line	Data
de56a948 PM	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License, version 2, as
	4	* published by the Free Software Foundation.
	5	*
	6	* This program is distributed in the hope that it will be useful,
	7	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	8	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	9	* GNU General Public License for more details.
	10	*
	11	* You should have received a copy of the GNU General Public License
	12	* along with this program; if not, write to the Free Software
	13	* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	14	*
	15	* Copyright 2010 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
	16	*/
	17
	18	#include <linux/types.h>
	19	#include <linux/string.h>
	20	#include <linux/kvm.h>
	21	#include <linux/kvm_host.h>
	22	#include <linux/highmem.h>
	23	#include <linux/gfp.h>
	24	#include <linux/slab.h>
	25	#include <linux/hugetlb.h>
8936dda4	26	#include <linux/vmalloc.h>
de56a948 PM	27
	28	#include <asm/tlbflush.h>
	29	#include <asm/kvm_ppc.h>
	30	#include <asm/kvm_book3s.h>
	31	#include <asm/mmu-hash64.h>
	32	#include <asm/hvcall.h>
	33	#include <asm/synch.h>
	34	#include <asm/ppc-opcode.h>
	35	#include <asm/cputable.h>
	36
de56a948 PM	37	#define VRMA_VSID 0x1ffffffUL /* 1TB VSID reserved for VRMA */
de56a948 PM	38
9e368f29 PM	39	/* POWER7 has 10-bit LPIDs, PPC970 has 6-bit LPIDs */
9e368f29 PM	40	#define MAX_LPID_970 63
de56a948 PM	41	#define NR_LPIDS (LPID_RSVD + 1)
	42	unsigned long lpid_inuse[BITS_TO_LONGS(NR_LPIDS)];
	43
	44	long kvmppc_alloc_hpt(struct kvm *kvm)
	45	{
	46	unsigned long hpt;
	47	unsigned long lpid;
8936dda4	48	struct revmap_entry *rev;
de56a948	49
8936dda4	50	/* Allocate guest's hashed page table */
de56a948 PM	51	hpt = __get_free_pages(GFP_KERNEL\|__GFP_ZERO\|__GFP_REPEAT\|__GFP_NOWARN,
	52	HPT_ORDER - PAGE_SHIFT);
	53	if (!hpt) {
	54	pr_err("kvm_alloc_hpt: Couldn't alloc HPT\n");
	55	return -ENOMEM;
	56	}
	57	kvm->arch.hpt_virt = hpt;
	58
8936dda4 PM	59	/* Allocate reverse map array */
	60	rev = vmalloc(sizeof(struct revmap_entry) * HPT_NPTE);
	61	if (!rev) {
	62	pr_err("kvmppc_alloc_hpt: Couldn't alloc reverse map array\n");
	63	goto out_freehpt;
	64	}
	65	kvm->arch.revmap = rev;
	66
	67	/* Allocate the guest's logical partition ID */
de56a948 PM	68	do {
	69	lpid = find_first_zero_bit(lpid_inuse, NR_LPIDS);
	70	if (lpid >= NR_LPIDS) {
	71	pr_err("kvm_alloc_hpt: No LPIDs free\n");
8936dda4	72	goto out_freeboth;
de56a948 PM	73	}
	74	} while (test_and_set_bit(lpid, lpid_inuse));
	75
	76	kvm->arch.sdr1 = __pa(hpt) \| (HPT_ORDER - 18);
	77	kvm->arch.lpid = lpid;
de56a948 PM	78
	79	pr_info("KVM guest htab at %lx, LPID %lx\n", hpt, lpid);
	80	return 0;
8936dda4 PM	81
	82	out_freeboth:
	83	vfree(rev);
	84	out_freehpt:
	85	free_pages(hpt, HPT_ORDER - PAGE_SHIFT);
	86	return -ENOMEM;
de56a948 PM	87	}
	88
	89	void kvmppc_free_hpt(struct kvm *kvm)
	90	{
de56a948	91	clear_bit(kvm->arch.lpid, lpid_inuse);
8936dda4	92	vfree(kvm->arch.revmap);
de56a948	93	free_pages(kvm->arch.hpt_virt, HPT_ORDER - PAGE_SHIFT);
de56a948 PM	94	}
de56a948 PM	95
da9d1d7f PM	96	/* Bits in first HPTE dword for pagesize 4k, 64k or 16M */
	97	static inline unsigned long hpte0_pgsize_encoding(unsigned long pgsize)
	98	{
	99	return (pgsize > 0x1000) ? HPTE_V_LARGE : 0;
	100	}
	101
	102	/* Bits in second HPTE dword for pagesize 4k, 64k or 16M */
	103	static inline unsigned long hpte1_pgsize_encoding(unsigned long pgsize)
	104	{
	105	return (pgsize == 0x10000) ? 0x1000 : 0;
	106	}
	107
	108	void kvmppc_map_vrma(struct kvm_vcpu vcpu, struct kvm_memory_slot memslot,
	109	unsigned long porder)
de56a948 PM	110	{
de56a948 PM	111	unsigned long i;
b2b2f165	112	unsigned long npages;
c77162de PM	113	unsigned long hp_v, hp_r;
c77162de PM	114	unsigned long addr, hash;
da9d1d7f PM	115	unsigned long psize;
da9d1d7f PM	116	unsigned long hp0, hp1;
c77162de	117	long ret;
de56a948	118
da9d1d7f PM	119	psize = 1ul << porder;
da9d1d7f PM	120	npages = memslot->npages >> (porder - PAGE_SHIFT);
de56a948 PM	121
de56a948 PM	122	/* VRMA can't be > 1TB */
8936dda4 PM	123	if (npages > 1ul << (40 - porder))
8936dda4 PM	124	npages = 1ul << (40 - porder);
de56a948 PM	125	/* Can't use more than 1 HPTE per HPTEG */
	126	if (npages > HPT_NPTEG)
	127	npages = HPT_NPTEG;
	128
da9d1d7f PM	129	hp0 = HPTE_V_1TB_SEG \| (VRMA_VSID << (40 - 16)) \|
	130	HPTE_V_BOLTED \| hpte0_pgsize_encoding(psize);
	131	hp1 = hpte1_pgsize_encoding(psize) \|
	132	HPTE_R_R \| HPTE_R_C \| HPTE_R_M \| PP_RWXX;
	133
de56a948	134	for (i = 0; i < npages; ++i) {
c77162de	135	addr = i << porder;
de56a948 PM	136	/* can't use hpt_hash since va > 64 bits */
	137	hash = (i ^ (VRMA_VSID ^ (VRMA_VSID << 25))) & HPT_HASH_MASK;
	138	/*
	139	* We assume that the hash table is empty and no
	140	* vcpus are using it at this stage. Since we create
	141	* at most one HPTE per HPTEG, we just assume entry 7
	142	* is available and use it.
	143	*/
8936dda4	144	hash = (hash << 3) + 7;
da9d1d7f PM	145	hp_v = hp0 \| ((addr >> 16) & ~0x7fUL);
da9d1d7f PM	146	hp_r = hp1 \| addr;
c77162de PM	147	ret = kvmppc_virtmode_h_enter(vcpu, H_EXACT, hash, hp_v, hp_r);
	148	if (ret != H_SUCCESS) {
	149	pr_err("KVM: map_vrma at %lx failed, ret=%ld\n",
	150	addr, ret);
	151	break;
	152	}
de56a948 PM	153	}
	154	}
	155
	156	int kvmppc_mmu_hv_init(void)
	157	{
9e368f29 PM	158	unsigned long host_lpid, rsvd_lpid;
	159
	160	if (!cpu_has_feature(CPU_FTR_HVMODE))
de56a948	161	return -EINVAL;
9e368f29	162
de56a948	163	memset(lpid_inuse, 0, sizeof(lpid_inuse));
9e368f29 PM	164
	165	if (cpu_has_feature(CPU_FTR_ARCH_206)) {
	166	host_lpid = mfspr(SPRN_LPID); /* POWER7 */
	167	rsvd_lpid = LPID_RSVD;
	168	} else {
	169	host_lpid = 0; /* PPC970 */
	170	rsvd_lpid = MAX_LPID_970;
	171	}
	172
	173	set_bit(host_lpid, lpid_inuse);
	174	/* rsvd_lpid is reserved for use in partition switching */
	175	set_bit(rsvd_lpid, lpid_inuse);
de56a948 PM	176
	177	return 0;
	178	}
	179
	180	void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu)
	181	{
	182	}
	183
	184	static void kvmppc_mmu_book3s_64_hv_reset_msr(struct kvm_vcpu *vcpu)
	185	{
	186	kvmppc_set_msr(vcpu, MSR_SF \| MSR_ME);
	187	}
	188
c77162de PM	189	/*
	190	* This is called to get a reference to a guest page if there isn't
	191	* one already in the kvm->arch.slot_phys[][] arrays.
	192	*/
	193	static long kvmppc_get_guest_page(struct kvm *kvm, unsigned long gfn,
da9d1d7f PM	194	struct kvm_memory_slot *memslot,
da9d1d7f PM	195	unsigned long psize)
c77162de PM	196	{
c77162de PM	197	unsigned long start;
da9d1d7f PM	198	long np, err;
	199	struct page page, hpage, *pages[1];
	200	unsigned long s, pgsize;
c77162de	201	unsigned long *physp;
da9d1d7f PM	202	unsigned int got, pgorder;
da9d1d7f PM	203	unsigned long pfn, i, npages;
c77162de PM	204
	205	physp = kvm->arch.slot_phys[memslot->id];
	206	if (!physp)
	207	return -EINVAL;
da9d1d7f	208	if (physp[gfn - memslot->base_gfn])
c77162de PM	209	return 0;
	210
	211	page = NULL;
da9d1d7f	212	pgsize = psize;
c77162de PM	213	start = gfn_to_hva_memslot(memslot, gfn);
	214
	215	/* Instantiate and get the page we want access to */
	216	np = get_user_pages_fast(start, 1, 1, pages);
	217	if (np != 1)
	218	return -EINVAL;
	219	page = pages[0];
da9d1d7f PM	220	got = KVMPPC_GOT_PAGE;
	221
	222	/* See if this is a large page */
	223	s = PAGE_SIZE;
	224	if (PageHuge(page)) {
	225	hpage = compound_head(page);
	226	s <<= compound_order(hpage);
	227	/* Get the whole large page if slot alignment is ok */
	228	if (s > psize && slot_is_aligned(memslot, s) &&
	229	!(memslot->userspace_addr & (s - 1))) {
	230	start &= ~(s - 1);
	231	pgsize = s;
	232	page = hpage;
	233	}
c77162de	234	}
da9d1d7f PM	235	err = -EINVAL;
	236	if (s < psize)
	237	goto out;
c77162de PM	238	pfn = page_to_pfn(page);
c77162de PM	239
da9d1d7f PM	240	npages = pgsize >> PAGE_SHIFT;
	241	pgorder = __ilog2(npages);
	242	physp += (gfn - memslot->base_gfn) & ~(npages - 1);
c77162de	243	spin_lock(&kvm->arch.slot_phys_lock);
da9d1d7f PM	244	for (i = 0; i < npages; ++i) {
	245	if (!physp[i]) {
	246	physp[i] = ((pfn + i) << PAGE_SHIFT) + got + pgorder;
	247	got = 0;
	248	}
	249	}
c77162de	250	spin_unlock(&kvm->arch.slot_phys_lock);
da9d1d7f	251	err = 0;
c77162de	252
da9d1d7f PM	253	out:
	254	if (got) {
	255	if (PageHuge(page))
	256	page = compound_head(page);
	257	put_page(page);
	258	}
	259	return err;
c77162de PM	260	}
	261
	262	/*
	263	* We come here on a H_ENTER call from the guest when
	264	* we don't have the requested page pinned already.
	265	*/
	266	long kvmppc_virtmode_h_enter(struct kvm_vcpu *vcpu, unsigned long flags,
	267	long pte_index, unsigned long pteh, unsigned long ptel)
	268	{
	269	struct kvm *kvm = vcpu->kvm;
	270	unsigned long psize, gpa, gfn;
	271	struct kvm_memory_slot *memslot;
	272	long ret;
	273
	274	psize = hpte_page_size(pteh, ptel);
	275	if (!psize)
	276	return H_PARAMETER;
	277
	278	/* Find the memslot (if any) for this address */
	279	gpa = (ptel & HPTE_R_RPN) & ~(psize - 1);
	280	gfn = gpa >> PAGE_SHIFT;
	281	memslot = gfn_to_memslot(kvm, gfn);
	282	if (!memslot \|\| (memslot->flags & KVM_MEMSLOT_INVALID))
	283	return H_PARAMETER;
da9d1d7f PM	284	if (!slot_is_aligned(memslot, psize))
	285	return H_PARAMETER;
	286	if (kvmppc_get_guest_page(kvm, gfn, memslot, psize) < 0)
c77162de PM	287	return H_PARAMETER;
	288
	289	preempt_disable();
	290	ret = kvmppc_h_enter(vcpu, flags, pte_index, pteh, ptel);
	291	preempt_enable();
	292	if (ret == H_TOO_HARD) {
	293	/* this can't happen */
	294	pr_err("KVM: Oops, kvmppc_h_enter returned too hard!\n");
	295	ret = H_RESOURCE; /* or something */
	296	}
	297	return ret;
	298
	299	}
	300
de56a948 PM	301	static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
	302	struct kvmppc_pte *gpte, bool data)
	303	{
	304	return -ENOENT;
	305	}
	306
93e60249 PM	307	void kvmppc_pin_guest_page(struct kvm kvm, unsigned long gpa,
	308	unsigned long *nb_ret)
	309	{
	310	struct kvm_memory_slot *memslot;
	311	unsigned long gfn = gpa >> PAGE_SHIFT;
	312	struct page *page;
da9d1d7f PM	313	unsigned long psize, offset;
da9d1d7f PM	314	unsigned long pa;
93e60249 PM	315	unsigned long *physp;
	316
	317	memslot = gfn_to_memslot(kvm, gfn);
	318	if (!memslot \|\| (memslot->flags & KVM_MEMSLOT_INVALID))
	319	return NULL;
	320	physp = kvm->arch.slot_phys[memslot->id];
	321	if (!physp)
	322	return NULL;
da9d1d7f	323	physp += gfn - memslot->base_gfn;
93e60249	324	pa = *physp;
c77162de	325	if (!pa) {
da9d1d7f	326	if (kvmppc_get_guest_page(kvm, gfn, memslot, PAGE_SIZE) < 0)
c77162de PM	327	return NULL;
	328	pa = *physp;
	329	}
da9d1d7f PM	330	page = pfn_to_page(pa >> PAGE_SHIFT);
	331	psize = PAGE_SIZE;
	332	if (PageHuge(page)) {
	333	page = compound_head(page);
	334	psize <<= compound_order(page);
	335	}
93e60249	336	get_page(page);
da9d1d7f	337	offset = gpa & (psize - 1);
93e60249	338	if (nb_ret)
da9d1d7f	339	*nb_ret = psize - offset;
93e60249 PM	340	return page_address(page) + offset;
	341	}
	342
	343	void kvmppc_unpin_guest_page(struct kvm kvm, void va)
	344	{
	345	struct page *page = virt_to_page(va);
	346
	347	page = compound_head(page);
	348	put_page(page);
	349	}
	350
de56a948 PM	351	void kvmppc_mmu_book3s_hv_init(struct kvm_vcpu *vcpu)
	352	{
	353	struct kvmppc_mmu *mmu = &vcpu->arch.mmu;
	354
9e368f29 PM	355	if (cpu_has_feature(CPU_FTR_ARCH_206))
	356	vcpu->arch.slb_nr = 32; /* POWER7 */
	357	else
	358	vcpu->arch.slb_nr = 64;
de56a948 PM	359
	360	mmu->xlate = kvmppc_mmu_book3s_64_hv_xlate;
	361	mmu->reset_msr = kvmppc_mmu_book3s_64_hv_reset_msr;
	362
	363	vcpu->arch.hflags \|= BOOK3S_HFLAG_SLB;
	364	}