[mirror_ubuntu-bionic-kernel.git] / arch / powerpc / kvm / book3s_pr_papr.c

/*
 * Copyright (C) 2011. Freescale Inc. All rights reserved.
 *
 * Authors:
 *    Alexander Graf <agraf@suse.de>
 *    Paul Mackerras <paulus@samba.org>
 *
 * Description:
 *
 * Hypercall handling for running PAPR guests in PR KVM on Book 3S
 * processors.
 *
 * 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/anon_inodes.h>

#include <linux/uaccess.h>
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s.h>

#define HPTE_SIZE	16		/* bytes per HPT entry */

static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
{
	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
	unsigned long pteg_addr;

	pte_index <<= 4;
	pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70;
	pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
	pteg_addr |= pte_index;

	return pteg_addr;
}

static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
{
	long flags = kvmppc_get_gpr(vcpu, 4);
	long pte_index = kvmppc_get_gpr(vcpu, 5);
	__be64 pteg[2 * 8];
	__be64 *hpte;
	unsigned long pteg_addr, i;
	long int ret;

	i = pte_index & 7;
	pte_index &= ~7UL;
	pteg_addr = get_pteg_addr(vcpu, pte_index);

	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
	ret = H_FUNCTION;
	if (copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)))
		goto done;
	hpte = pteg;

	ret = H_PTEG_FULL;
	if (likely((flags & H_EXACT) == 0)) {
		for (i = 0; ; ++i) {
			if (i == 8)
				goto done;
			if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
				break;
			hpte += 2;
		}
	} else {
		hpte += i * 2;
		if (*hpte & HPTE_V_VALID)
			goto done;
	}

	hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
	hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
	pteg_addr += i * HPTE_SIZE;
	ret = H_FUNCTION;
	if (copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE))
		goto done;
	kvmppc_set_gpr(vcpu, 4, pte_index | i);
	ret = H_SUCCESS;

 done:
	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	kvmppc_set_gpr(vcpu, 3, ret);

	return EMULATE_DONE;
}

static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
{
	unsigned long flags= kvmppc_get_gpr(vcpu, 4);
	unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
	unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
	unsigned long v = 0, pteg, rb;
	unsigned long pte[2];
	long int ret;

	pteg = get_pteg_addr(vcpu, pte_index);
	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
	ret = H_FUNCTION;
	if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
		goto done;
	pte[0] = be64_to_cpu((__force __be64)pte[0]);
	pte[1] = be64_to_cpu((__force __be64)pte[1]);

	ret = H_NOT_FOUND;
	if ((pte[0] & HPTE_V_VALID) == 0 ||
	    ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
	    ((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
		goto done;

	ret = H_FUNCTION;
	if (copy_to_user((void __user *)pteg, &v, sizeof(v)))
		goto done;

	rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
	vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);

	ret = H_SUCCESS;
	kvmppc_set_gpr(vcpu, 4, pte[0]);
	kvmppc_set_gpr(vcpu, 5, pte[1]);

 done:
	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	kvmppc_set_gpr(vcpu, 3, ret);

	return EMULATE_DONE;
}

/* Request defs for kvmppc_h_pr_bulk_remove() */
#define H_BULK_REMOVE_TYPE             0xc000000000000000ULL
#define   H_BULK_REMOVE_REQUEST        0x4000000000000000ULL
#define   H_BULK_REMOVE_RESPONSE       0x8000000000000000ULL
#define   H_BULK_REMOVE_END            0xc000000000000000ULL
#define H_BULK_REMOVE_CODE             0x3000000000000000ULL
#define   H_BULK_REMOVE_SUCCESS        0x0000000000000000ULL
#define   H_BULK_REMOVE_NOT_FOUND      0x1000000000000000ULL
#define   H_BULK_REMOVE_PARM           0x2000000000000000ULL
#define   H_BULK_REMOVE_HW             0x3000000000000000ULL
#define H_BULK_REMOVE_RC               0x0c00000000000000ULL
#define H_BULK_REMOVE_FLAGS            0x0300000000000000ULL
#define   H_BULK_REMOVE_ABSOLUTE       0x0000000000000000ULL
#define   H_BULK_REMOVE_ANDCOND        0x0100000000000000ULL
#define   H_BULK_REMOVE_AVPN           0x0200000000000000ULL
#define H_BULK_REMOVE_PTEX             0x00ffffffffffffffULL
#define H_BULK_REMOVE_MAX_BATCH        4

static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
{
	int i;
	int paramnr = 4;
	int ret = H_SUCCESS;

	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
	for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
		unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
		unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
		unsigned long pteg, rb, flags;
		unsigned long pte[2];
		unsigned long v = 0;

		if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
			break; /* Exit success */
		} else if ((tsh & H_BULK_REMOVE_TYPE) !=
			   H_BULK_REMOVE_REQUEST) {
			ret = H_PARAMETER;
			break; /* Exit fail */
		}

		tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
		tsh |= H_BULK_REMOVE_RESPONSE;

		if ((tsh & H_BULK_REMOVE_ANDCOND) &&
		    (tsh & H_BULK_REMOVE_AVPN)) {
			tsh |= H_BULK_REMOVE_PARM;
			kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
			ret = H_PARAMETER;
			break; /* Exit fail */
		}

		pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
		if (copy_from_user(pte, (void __user *)pteg, sizeof(pte))) {
			ret = H_FUNCTION;
			break;
		}
		pte[0] = be64_to_cpu((__force __be64)pte[0]);
		pte[1] = be64_to_cpu((__force __be64)pte[1]);

		/* tsl = AVPN */
		flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;

		if ((pte[0] & HPTE_V_VALID) == 0 ||
		    ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
		    ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
			tsh |= H_BULK_REMOVE_NOT_FOUND;
		} else {
			/* Splat the pteg in (userland) hpt */
			if (copy_to_user((void __user *)pteg, &v, sizeof(v))) {
				ret = H_FUNCTION;
				break;
			}

			rb = compute_tlbie_rb(pte[0], pte[1],
					      tsh & H_BULK_REMOVE_PTEX);
			vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
			tsh |= H_BULK_REMOVE_SUCCESS;
			tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
		}
		kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
	}
	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	kvmppc_set_gpr(vcpu, 3, ret);

	return EMULATE_DONE;
}

static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
{
	unsigned long flags = kvmppc_get_gpr(vcpu, 4);
	unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
	unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
	unsigned long rb, pteg, r, v;
	unsigned long pte[2];
	long int ret;

	pteg = get_pteg_addr(vcpu, pte_index);
	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
	ret = H_FUNCTION;
	if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
		goto done;
	pte[0] = be64_to_cpu((__force __be64)pte[0]);
	pte[1] = be64_to_cpu((__force __be64)pte[1]);

	ret = H_NOT_FOUND;
	if ((pte[0] & HPTE_V_VALID) == 0 ||
	    ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
		goto done;

	v = pte[0];
	r = pte[1];
	r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
	       HPTE_R_KEY_LO);
	r |= (flags << 55) & HPTE_R_PP0;
	r |= (flags << 48) & HPTE_R_KEY_HI;
	r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);

	pte[1] = r;

	rb = compute_tlbie_rb(v, r, pte_index);
	vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
	pte[0] = (__force u64)cpu_to_be64(pte[0]);
	pte[1] = (__force u64)cpu_to_be64(pte[1]);
	ret = H_FUNCTION;
	if (copy_to_user((void __user *)pteg, pte, sizeof(pte)))
		goto done;
	ret = H_SUCCESS;

 done:
	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	kvmppc_set_gpr(vcpu, 3, ret);

	return EMULATE_DONE;
}

static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu)
{
	long rc;

	rc = kvmppc_h_logical_ci_load(vcpu);
	if (rc == H_TOO_HARD)
		return EMULATE_FAIL;
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu)
{
	long rc;

	rc = kvmppc_h_logical_ci_store(vcpu);
	if (rc == H_TOO_HARD)
		return EMULATE_FAIL;
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

#ifdef CONFIG_SPAPR_TCE_IOMMU
static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
{
	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	unsigned long tce = kvmppc_get_gpr(vcpu, 6);
	long rc;

	rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
	if (rc == H_TOO_HARD)
		return EMULATE_FAIL;
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
{
	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	unsigned long tce = kvmppc_get_gpr(vcpu, 6);
	unsigned long npages = kvmppc_get_gpr(vcpu, 7);
	long rc;

	rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba,
			tce, npages);
	if (rc == H_TOO_HARD)
		return EMULATE_FAIL;
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
{
	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
	unsigned long npages = kvmppc_get_gpr(vcpu, 7);
	long rc;

	rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages);
	if (rc == H_TOO_HARD)
		return EMULATE_FAIL;
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

#else /* CONFIG_SPAPR_TCE_IOMMU */
static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
{
	return EMULATE_FAIL;
}

static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
{
	return EMULATE_FAIL;
}

static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
{
	return EMULATE_FAIL;
}
#endif /* CONFIG_SPAPR_TCE_IOMMU */

static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
{
	long rc = kvmppc_xics_hcall(vcpu, cmd);
	kvmppc_set_gpr(vcpu, 3, rc);
	return EMULATE_DONE;
}

int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
{
	int rc, idx;

	if (cmd <= MAX_HCALL_OPCODE &&
	    !test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls))
		return EMULATE_FAIL;

	switch (cmd) {
	case H_ENTER:
		return kvmppc_h_pr_enter(vcpu);
	case H_REMOVE:
		return kvmppc_h_pr_remove(vcpu);
	case H_PROTECT:
		return kvmppc_h_pr_protect(vcpu);
	case H_BULK_REMOVE:
		return kvmppc_h_pr_bulk_remove(vcpu);
	case H_PUT_TCE:
		return kvmppc_h_pr_put_tce(vcpu);
	case H_PUT_TCE_INDIRECT:
		return kvmppc_h_pr_put_tce_indirect(vcpu);
	case H_STUFF_TCE:
		return kvmppc_h_pr_stuff_tce(vcpu);
	case H_CEDE:
		kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE);
		kvm_vcpu_block(vcpu);
		kvm_clear_request(KVM_REQ_UNHALT, vcpu);
		vcpu->stat.halt_wakeup++;
		return EMULATE_DONE;
	case H_LOGICAL_CI_LOAD:
		return kvmppc_h_pr_logical_ci_load(vcpu);
	case H_LOGICAL_CI_STORE:
		return kvmppc_h_pr_logical_ci_store(vcpu);
	case H_XIRR:
	case H_CPPR:
	case H_EOI:
	case H_IPI:
	case H_IPOLL:
	case H_XIRR_X:
		if (kvmppc_xics_enabled(vcpu))
			return kvmppc_h_pr_xics_hcall(vcpu, cmd);
		break;
	case H_RTAS:
		if (list_empty(&vcpu->kvm->arch.rtas_tokens))
			break;
		idx = srcu_read_lock(&vcpu->kvm->srcu);
		rc = kvmppc_rtas_hcall(vcpu);
		srcu_read_unlock(&vcpu->kvm->srcu, idx);
		if (rc)
			break;
		kvmppc_set_gpr(vcpu, 3, 0);
		return EMULATE_DONE;
	}

	return EMULATE_FAIL;
}

int kvmppc_hcall_impl_pr(unsigned long cmd)
{
	switch (cmd) {
	case H_ENTER:
	case H_REMOVE:
	case H_PROTECT:
	case H_BULK_REMOVE:
	case H_PUT_TCE:
	case H_PUT_TCE_INDIRECT:
	case H_STUFF_TCE:
	case H_CEDE:
	case H_LOGICAL_CI_LOAD:
	case H_LOGICAL_CI_STORE:
#ifdef CONFIG_KVM_XICS
	case H_XIRR:
	case H_CPPR:
	case H_EOI:
	case H_IPI:
	case H_IPOLL:
	case H_XIRR_X:
#endif
		return 1;
	}
	return 0;
}

/*
 * List of hcall numbers to enable by default.
 * For compatibility with old userspace, we enable by default
 * all hcalls that were implemented before the hcall-enabling
 * facility was added.  Note this list should not include H_RTAS.
 */
static unsigned int default_hcall_list[] = {
	H_ENTER,
	H_REMOVE,
	H_PROTECT,
	H_BULK_REMOVE,
	H_PUT_TCE,
	H_CEDE,
#ifdef CONFIG_KVM_XICS
	H_XIRR,
	H_CPPR,
	H_EOI,
	H_IPI,
	H_IPOLL,
	H_XIRR_X,
#endif
	0
};

void kvmppc_pr_init_default_hcalls(struct kvm *kvm)
{
	int i;
	unsigned int hcall;

	for (i = 0; default_hcall_list[i]; ++i) {
		hcall = default_hcall_list[i];
		WARN_ON(!kvmppc_hcall_impl_pr(hcall));
		__set_bit(hcall / 4, kvm->arch.enabled_hcalls);
	}
}
Commit	Line	Data
0254f074 AG	1	/*
	2	* Copyright (C) 2011. Freescale Inc. All rights reserved.
	3	*
	4	* Authors:
	5	* Alexander Graf <agraf@suse.de>
	6	* Paul Mackerras <paulus@samba.org>
	7	*
	8	* Description:
	9	*
	10	* Hypercall handling for running PAPR guests in PR KVM on Book 3S
	11	* processors.
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License, version 2, as
	15	* published by the Free Software Foundation.
	16	*/
	17
f31e65e1 BH	18	#include <linux/anon_inodes.h>
f31e65e1 BH	19
7c0f6ba6	20	#include <linux/uaccess.h>
0254f074 AG	21	#include <asm/kvm_ppc.h>
	22	#include <asm/kvm_book3s.h>
	23
5cd92a95 PM	24	#define HPTE_SIZE 16 /* bytes per HPT entry */
5cd92a95 PM	25
0254f074 AG	26	static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
	27	{
	28	struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
	29	unsigned long pteg_addr;
	30
	31	pte_index <<= 4;
	32	pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 \| 0x70;
	33	pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
	34	pteg_addr \|= pte_index;
	35
	36	return pteg_addr;
	37	}
	38
	39	static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
	40	{
	41	long flags = kvmppc_get_gpr(vcpu, 4);
	42	long pte_index = kvmppc_get_gpr(vcpu, 5);
f396df35 AG	43	__be64 pteg[2 * 8];
	44	__be64 *hpte;
	45	unsigned long pteg_addr, i;
5cd92a95	46	long int ret;
0254f074	47
5cd92a95	48	i = pte_index & 7;
0254f074 AG	49	pte_index &= ~7UL;
	50	pteg_addr = get_pteg_addr(vcpu, pte_index);
	51
9308ab8e	52	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
67325e98 PM	53	ret = H_FUNCTION;
	54	if (copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)))
	55	goto done;
0254f074 AG	56	hpte = pteg;
0254f074 AG	57
5cd92a95	58	ret = H_PTEG_FULL;
0254f074	59	if (likely((flags & H_EXACT) == 0)) {
0254f074 AG	60	for (i = 0; ; ++i) {
0254f074 AG	61	if (i == 8)
5cd92a95	62	goto done;
1692aa3f	63	if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
0254f074 AG	64	break;
	65	hpte += 2;
	66	}
	67	} else {
0254f074	68	hpte += i * 2;
5cd92a95 PM	69	if (*hpte & HPTE_V_VALID)
5cd92a95 PM	70	goto done;
0254f074 AG	71	}
0254f074 AG	72
1692aa3f AG	73	hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
1692aa3f AG	74	hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
5cd92a95	75	pteg_addr += i * HPTE_SIZE;
67325e98 PM	76	ret = H_FUNCTION;
	77	if (copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE))
	78	goto done;
0254f074	79	kvmppc_set_gpr(vcpu, 4, pte_index \| i);
5cd92a95 PM	80	ret = H_SUCCESS;
	81
	82	done:
9308ab8e	83	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
5cd92a95	84	kvmppc_set_gpr(vcpu, 3, ret);
0254f074 AG	85
	86	return EMULATE_DONE;
	87	}
	88
	89	static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
	90	{
	91	unsigned long flags= kvmppc_get_gpr(vcpu, 4);
	92	unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
	93	unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
	94	unsigned long v = 0, pteg, rb;
	95	unsigned long pte[2];
9308ab8e	96	long int ret;
0254f074 AG	97
0254f074 AG	98	pteg = get_pteg_addr(vcpu, pte_index);
9308ab8e	99	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
67325e98 PM	100	ret = H_FUNCTION;
	101	if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
	102	goto done;
f396df35 AG	103	pte[0] = be64_to_cpu((__force __be64)pte[0]);
f396df35 AG	104	pte[1] = be64_to_cpu((__force __be64)pte[1]);
0254f074	105
9308ab8e	106	ret = H_NOT_FOUND;
0254f074 AG	107	if ((pte[0] & HPTE_V_VALID) == 0 \|\|
0254f074 AG	108	((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) \|\|
9308ab8e PM	109	((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
9308ab8e PM	110	goto done;
0254f074	111
67325e98 PM	112	ret = H_FUNCTION;
	113	if (copy_to_user((void __user *)pteg, &v, sizeof(v)))
	114	goto done;
0254f074 AG	115
	116	rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
	117	vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
	118
9308ab8e	119	ret = H_SUCCESS;
0254f074 AG	120	kvmppc_set_gpr(vcpu, 4, pte[0]);
	121	kvmppc_set_gpr(vcpu, 5, pte[1]);
	122
9308ab8e PM	123	done:
	124	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	125	kvmppc_set_gpr(vcpu, 3, ret);
	126
0254f074 AG	127	return EMULATE_DONE;
	128	}
	129
3aaefef2 ME	130	/* Request defs for kvmppc_h_pr_bulk_remove() */
	131	#define H_BULK_REMOVE_TYPE 0xc000000000000000ULL
	132	#define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL
	133	#define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL
	134	#define H_BULK_REMOVE_END 0xc000000000000000ULL
	135	#define H_BULK_REMOVE_CODE 0x3000000000000000ULL
	136	#define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL
	137	#define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL
	138	#define H_BULK_REMOVE_PARM 0x2000000000000000ULL
	139	#define H_BULK_REMOVE_HW 0x3000000000000000ULL
	140	#define H_BULK_REMOVE_RC 0x0c00000000000000ULL
	141	#define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL
	142	#define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL
	143	#define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL
	144	#define H_BULK_REMOVE_AVPN 0x0200000000000000ULL
	145	#define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL
	146	#define H_BULK_REMOVE_MAX_BATCH 4
	147
	148	static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
	149	{
	150	int i;
	151	int paramnr = 4;
	152	int ret = H_SUCCESS;
	153
9308ab8e	154	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
3aaefef2 ME	155	for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
	156	unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
	157	unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
	158	unsigned long pteg, rb, flags;
	159	unsigned long pte[2];
	160	unsigned long v = 0;
	161
	162	if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
	163	break; /* Exit success */
	164	} else if ((tsh & H_BULK_REMOVE_TYPE) !=
	165	H_BULK_REMOVE_REQUEST) {
	166	ret = H_PARAMETER;
	167	break; /* Exit fail */
	168	}
	169
	170	tsh &= H_BULK_REMOVE_PTEX \| H_BULK_REMOVE_FLAGS;
	171	tsh \|= H_BULK_REMOVE_RESPONSE;
	172
	173	if ((tsh & H_BULK_REMOVE_ANDCOND) &&
	174	(tsh & H_BULK_REMOVE_AVPN)) {
	175	tsh \|= H_BULK_REMOVE_PARM;
	176	kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
	177	ret = H_PARAMETER;
	178	break; /* Exit fail */
	179	}
	180
	181	pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
67325e98 PM	182	if (copy_from_user(pte, (void __user *)pteg, sizeof(pte))) {
	183	ret = H_FUNCTION;
	184	break;
	185	}
f396df35 AG	186	pte[0] = be64_to_cpu((__force __be64)pte[0]);
f396df35 AG	187	pte[1] = be64_to_cpu((__force __be64)pte[1]);
3aaefef2 ME	188
	189	/* tsl = AVPN */
	190	flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;
	191
	192	if ((pte[0] & HPTE_V_VALID) == 0 \|\|
	193	((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) \|\|
	194	((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
	195	tsh \|= H_BULK_REMOVE_NOT_FOUND;
	196	} else {
	197	/* Splat the pteg in (userland) hpt */
67325e98 PM	198	if (copy_to_user((void __user *)pteg, &v, sizeof(v))) {
	199	ret = H_FUNCTION;
	200	break;
	201	}
3aaefef2 ME	202
	203	rb = compute_tlbie_rb(pte[0], pte[1],
	204	tsh & H_BULK_REMOVE_PTEX);
	205	vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
	206	tsh \|= H_BULK_REMOVE_SUCCESS;
	207	tsh \|= (pte[1] & (HPTE_R_C \| HPTE_R_R)) << 43;
	208	}
	209	kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
	210	}
9308ab8e	211	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
3aaefef2 ME	212	kvmppc_set_gpr(vcpu, 3, ret);
	213
	214	return EMULATE_DONE;
	215	}
	216
0254f074 AG	217	static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
	218	{
	219	unsigned long flags = kvmppc_get_gpr(vcpu, 4);
	220	unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
	221	unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
	222	unsigned long rb, pteg, r, v;
	223	unsigned long pte[2];
9308ab8e	224	long int ret;
0254f074 AG	225
0254f074 AG	226	pteg = get_pteg_addr(vcpu, pte_index);
9308ab8e	227	mutex_lock(&vcpu->kvm->arch.hpt_mutex);
67325e98 PM	228	ret = H_FUNCTION;
	229	if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
	230	goto done;
f396df35 AG	231	pte[0] = be64_to_cpu((__force __be64)pte[0]);
f396df35 AG	232	pte[1] = be64_to_cpu((__force __be64)pte[1]);
0254f074	233
9308ab8e	234	ret = H_NOT_FOUND;
0254f074	235	if ((pte[0] & HPTE_V_VALID) == 0 \|\|
9308ab8e PM	236	((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
9308ab8e PM	237	goto done;
0254f074 AG	238
	239	v = pte[0];
	240	r = pte[1];
	241	r &= ~(HPTE_R_PP0 \| HPTE_R_PP \| HPTE_R_N \| HPTE_R_KEY_HI \|
	242	HPTE_R_KEY_LO);
	243	r \|= (flags << 55) & HPTE_R_PP0;
	244	r \|= (flags << 48) & HPTE_R_KEY_HI;
	245	r \|= flags & (HPTE_R_PP \| HPTE_R_N \| HPTE_R_KEY_LO);
	246
	247	pte[1] = r;
	248
	249	rb = compute_tlbie_rb(v, r, pte_index);
	250	vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
f396df35 AG	251	pte[0] = (__force u64)cpu_to_be64(pte[0]);
f396df35 AG	252	pte[1] = (__force u64)cpu_to_be64(pte[1]);
67325e98 PM	253	ret = H_FUNCTION;
	254	if (copy_to_user((void __user *)pteg, pte, sizeof(pte)))
	255	goto done;
9308ab8e	256	ret = H_SUCCESS;
0254f074	257
9308ab8e PM	258	done:
	259	mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
	260	kvmppc_set_gpr(vcpu, 3, ret);
0254f074 AG	261
	262	return EMULATE_DONE;
	263	}
	264
76d837a4	265	static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu)
f31e65e1	266	{
f31e65e1 BH	267	long rc;
f31e65e1 BH	268
76d837a4	269	rc = kvmppc_h_logical_ci_load(vcpu);
f31e65e1 BH	270	if (rc == H_TOO_HARD)
	271	return EMULATE_FAIL;
	272	kvmppc_set_gpr(vcpu, 3, rc);
	273	return EMULATE_DONE;
	274	}
	275
76d837a4	276	static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu)
99342cf8 DG	277	{
	278	long rc;
	279
76d837a4	280	rc = kvmppc_h_logical_ci_store(vcpu);
99342cf8 DG	281	if (rc == H_TOO_HARD)
	282	return EMULATE_FAIL;
	283	kvmppc_set_gpr(vcpu, 3, rc);
	284	return EMULATE_DONE;
	285	}
	286
76d837a4 PM	287	#ifdef CONFIG_SPAPR_TCE_IOMMU
76d837a4 PM	288	static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
99342cf8	289	{
76d837a4 PM	290	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	291	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	292	unsigned long tce = kvmppc_get_gpr(vcpu, 6);
99342cf8 DG	293	long rc;
99342cf8 DG	294
76d837a4	295	rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
99342cf8 DG	296	if (rc == H_TOO_HARD)
	297	return EMULATE_FAIL;
	298	kvmppc_set_gpr(vcpu, 3, rc);
	299	return EMULATE_DONE;
	300	}
	301
d3695aa4 AK	302	static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
	303	{
	304	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	305	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	306	unsigned long tce = kvmppc_get_gpr(vcpu, 6);
	307	unsigned long npages = kvmppc_get_gpr(vcpu, 7);
	308	long rc;
	309
	310	rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba,
	311	tce, npages);
	312	if (rc == H_TOO_HARD)
	313	return EMULATE_FAIL;
	314	kvmppc_set_gpr(vcpu, 3, rc);
	315	return EMULATE_DONE;
	316	}
	317
	318	static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
	319	{
	320	unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
	321	unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
	322	unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
	323	unsigned long npages = kvmppc_get_gpr(vcpu, 7);
	324	long rc;
	325
	326	rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages);
	327	if (rc == H_TOO_HARD)
	328	return EMULATE_FAIL;
	329	kvmppc_set_gpr(vcpu, 3, rc);
	330	return EMULATE_DONE;
	331	}
	332
76d837a4 PM	333	#else /* CONFIG_SPAPR_TCE_IOMMU */
	334	static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
	335	{
	336	return EMULATE_FAIL;
	337	}
	338
	339	static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
	340	{
	341	return EMULATE_FAIL;
	342	}
	343
	344	static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
	345	{
	346	return EMULATE_FAIL;
	347	}
	348	#endif /* CONFIG_SPAPR_TCE_IOMMU */
	349
bc5ad3f3 BH	350	static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
	351	{
	352	long rc = kvmppc_xics_hcall(vcpu, cmd);
	353	kvmppc_set_gpr(vcpu, 3, rc);
	354	return EMULATE_DONE;
	355	}
	356
0254f074 AG	357	int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
0254f074 AG	358	{
ef1af2e2 PM	359	int rc, idx;
ef1af2e2 PM	360
699a0ea0 PM	361	if (cmd <= MAX_HCALL_OPCODE &&
	362	!test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls))
	363	return EMULATE_FAIL;
	364
0254f074 AG	365	switch (cmd) {
	366	case H_ENTER:
	367	return kvmppc_h_pr_enter(vcpu);
	368	case H_REMOVE:
	369	return kvmppc_h_pr_remove(vcpu);
	370	case H_PROTECT:
	371	return kvmppc_h_pr_protect(vcpu);
	372	case H_BULK_REMOVE:
3aaefef2	373	return kvmppc_h_pr_bulk_remove(vcpu);
f31e65e1 BH	374	case H_PUT_TCE:
f31e65e1 BH	375	return kvmppc_h_pr_put_tce(vcpu);
d3695aa4 AK	376	case H_PUT_TCE_INDIRECT:
	377	return kvmppc_h_pr_put_tce_indirect(vcpu);
	378	case H_STUFF_TCE:
	379	return kvmppc_h_pr_stuff_tce(vcpu);
0254f074	380	case H_CEDE:
5deb8e7a	381	kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) \| MSR_EE);
0254f074	382	kvm_vcpu_block(vcpu);
72875d8a	383	kvm_clear_request(KVM_REQ_UNHALT, vcpu);
0254f074 AG	384	vcpu->stat.halt_wakeup++;
0254f074 AG	385	return EMULATE_DONE;
99342cf8 DG	386	case H_LOGICAL_CI_LOAD:
	387	return kvmppc_h_pr_logical_ci_load(vcpu);
	388	case H_LOGICAL_CI_STORE:
	389	return kvmppc_h_pr_logical_ci_store(vcpu);
bc5ad3f3 BH	390	case H_XIRR:
	391	case H_CPPR:
	392	case H_EOI:
	393	case H_IPI:
8e44ddc3 PM	394	case H_IPOLL:
8e44ddc3 PM	395	case H_XIRR_X:
bc5ad3f3 BH	396	if (kvmppc_xics_enabled(vcpu))
	397	return kvmppc_h_pr_xics_hcall(vcpu, cmd);
	398	break;
8e591cb7 ME	399	case H_RTAS:
8e591cb7 ME	400	if (list_empty(&vcpu->kvm->arch.rtas_tokens))
ef1af2e2 PM	401	break;
	402	idx = srcu_read_lock(&vcpu->kvm->srcu);
	403	rc = kvmppc_rtas_hcall(vcpu);
	404	srcu_read_unlock(&vcpu->kvm->srcu, idx);
	405	if (rc)
8e591cb7 ME	406	break;
	407	kvmppc_set_gpr(vcpu, 3, 0);
	408	return EMULATE_DONE;
0254f074 AG	409	}
	410
	411	return EMULATE_FAIL;
	412	}
699a0ea0	413
ae2113a4 PM	414	int kvmppc_hcall_impl_pr(unsigned long cmd)
	415	{
	416	switch (cmd) {
	417	case H_ENTER:
	418	case H_REMOVE:
	419	case H_PROTECT:
	420	case H_BULK_REMOVE:
	421	case H_PUT_TCE:
3f2bb764 AK	422	case H_PUT_TCE_INDIRECT:
3f2bb764 AK	423	case H_STUFF_TCE:
ae2113a4	424	case H_CEDE:
99342cf8 DG	425	case H_LOGICAL_CI_LOAD:
99342cf8 DG	426	case H_LOGICAL_CI_STORE:
ae2113a4 PM	427	#ifdef CONFIG_KVM_XICS
	428	case H_XIRR:
	429	case H_CPPR:
	430	case H_EOI:
	431	case H_IPI:
	432	case H_IPOLL:
	433	case H_XIRR_X:
	434	#endif
	435	return 1;
	436	}
	437	return 0;
	438	}
699a0ea0 PM	439
	440	/*
	441	* List of hcall numbers to enable by default.
	442	* For compatibility with old userspace, we enable by default
	443	* all hcalls that were implemented before the hcall-enabling
	444	* facility was added. Note this list should not include H_RTAS.
	445	*/
	446	static unsigned int default_hcall_list[] = {
	447	H_ENTER,
	448	H_REMOVE,
	449	H_PROTECT,
	450	H_BULK_REMOVE,
	451	H_PUT_TCE,
	452	H_CEDE,
	453	#ifdef CONFIG_KVM_XICS
	454	H_XIRR,
	455	H_CPPR,
	456	H_EOI,
	457	H_IPI,
	458	H_IPOLL,
	459	H_XIRR_X,
	460	#endif
	461	0
	462	};
	463
	464	void kvmppc_pr_init_default_hcalls(struct kvm *kvm)
	465	{
	466	int i;
ae2113a4	467	unsigned int hcall;
699a0ea0	468
ae2113a4 PM	469	for (i = 0; default_hcall_list[i]; ++i) {
	470	hcall = default_hcall_list[i];
	471	WARN_ON(!kvmppc_hcall_impl_pr(hcall));
	472	__set_bit(hcall / 4, kvm->arch.enabled_hcalls);
	473	}
699a0ea0	474	}