Commit 90e9311a authored by James Hogan's avatar James Hogan Committed by Paolo Bonzini
Browse files

MIPS; KVM: Convert exception entry to uasm 



Convert the whole of locore.S (assembly to enter guest and handle
exception entry) to be generated dynamically with uasm. This is done
with minimal changes to the resulting code.

The main changes are:
- Some constants are generated by uasm using LUI+ADDIU instead of
  LUI+ORI.
- Loading of lo and hi are swapped around in vcpu_run but not when
  resuming the guest after an exit. Both bits of logic are now generated
  by the same code.
- Register MOVEs in uasm use different ADDU operand ordering to GNU as,
  putting zero register into rs instead of rt.
- The JALR.HB to call the C exit handler is switched to JALR, since the
  hazard barrier would appear to be unnecessary.

This will allow further optimisation in the future to dynamically handle
the capabilities of the CPU.

Signed-off-by: default avatarJames Hogan <james.hogan@imgtec.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Radim KrÄmář <rkrcmar@redhat.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: linux-mips@linux-mips.org
Cc: kvm@vger.kernel.org
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 6f63405c

arch/mips/include/asm/kvm_host.h

+6 −2
Original line number Diff line number Diff line
@@ -533,8 +533,12 @@ int kvm_mips_emulation_init(struct kvm_mips_callbacks **install_callbacks); 
/* Debug: dump vcpu state */

int kvm_arch_vcpu_dump_regs(struct kvm_vcpu *vcpu);



/* Trampoline ASM routine to start running in "Guest" context */

extern int __kvm_mips_vcpu_run(struct kvm_run *run, struct kvm_vcpu *vcpu);

extern int kvm_mips_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu);



/* Building of entry/exception code */

void *kvm_mips_build_vcpu_run(void *addr);

void *kvm_mips_build_exception(void *addr);

void *kvm_mips_build_exit(void *addr);



/* FPU/MSA context management */

void __kvm_save_fpu(struct kvm_vcpu_arch *vcpu);

arch/mips/kvm/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ if VIRTUALIZATION 
config KVM

	tristate "Kernel-based Virtual Machine (KVM) support"

	depends on HAVE_KVM

	select EXPORT_UASM

	select PREEMPT_NOTIFIERS

	select ANON_INODES

	select KVM_MMIO

arch/mips/kvm/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ EXTRA_CFLAGS += -Ivirt/kvm -Iarch/mips/kvm 


common-objs-$(CONFIG_CPU_HAS_MSA) += msa.o



kvm-objs := $(common-objs-y) mips.o emulate.o locore.o \

kvm-objs := $(common-objs-y) mips.o emulate.o entry.o \

	    interrupt.o stats.o commpage.o \

	    dyntrans.o trap_emul.o fpu.o

kvm-objs += mmu.o

arch/mips/kvm/entry.c

0 → 100644
+622 −0
Original line number Diff line number Diff line 
/*

 * This file is subject to the terms and conditions of the GNU General Public

 * License.  See the file "COPYING" in the main directory of this archive

 * for more details.

 *

 * Generation of main entry point for the guest, exception handling.

 *

 * Copyright (C) 2012  MIPS Technologies, Inc.

 * Authors: Sanjay Lal <sanjayl@kymasys.com>

 *

 * Copyright (C) 2016 Imagination Technologies Ltd.

 */



#include <linux/kvm_host.h>

#include <asm/msa.h>

#include <asm/setup.h>

#include <asm/uasm.h>



/* Register names */

#define ZERO		0

#define AT		1

#define V0		2

#define V1		3

#define A0		4

#define A1		5



#if _MIPS_SIM == _MIPS_SIM_ABI32

#define T0		8

#define T1		9

#define T2		10

#define T3		11

#endif /* _MIPS_SIM == _MIPS_SIM_ABI32 */



#if _MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32

#define T0		12

#define T1		13

#define T2		14

#define T3		15

#endif /* _MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32 */



#define S0		16

#define S1		17

#define T9		25

#define K0		26

#define K1		27

#define GP		28

#define SP		29

#define RA		31



/* Some CP0 registers */

#define C0_HWRENA	7, 0

#define C0_BADVADDR	8, 0

#define C0_ENTRYHI	10, 0

#define C0_STATUS	12, 0

#define C0_CAUSE	13, 0

#define C0_EPC		14, 0

#define C0_EBASE	15, 1

#define C0_CONFIG3	16, 3

#define C0_CONFIG5	16, 5

#define C0_DDATA_LO	28, 3

#define C0_ERROREPC	30, 0



#define CALLFRAME_SIZ   32



enum label_id {

	label_fpu_1 = 1,

	label_msa_1,

	label_return_to_host,

	label_kernel_asid,

};



UASM_L_LA(_fpu_1)

UASM_L_LA(_msa_1)

UASM_L_LA(_return_to_host)

UASM_L_LA(_kernel_asid)



static void *kvm_mips_build_enter_guest(void *addr);

static void *kvm_mips_build_ret_from_exit(void *addr);

static void *kvm_mips_build_ret_to_guest(void *addr);

static void *kvm_mips_build_ret_to_host(void *addr);



/**

 * kvm_mips_build_vcpu_run() - Assemble function to start running a guest VCPU.

 * @addr:	Address to start writing code.

 *

 * Assemble the start of the vcpu_run function to run a guest VCPU. The function

 * conforms to the following prototype:

 *

 * int vcpu_run(struct kvm_run *run, struct kvm_vcpu *vcpu);

 *

 * The exit from the guest and return to the caller is handled by the code

 * generated by kvm_mips_build_ret_to_host().

 *

 * Returns:	Next address after end of written function.

 */

void *kvm_mips_build_vcpu_run(void *addr)

{

	u32 *p = addr;

	unsigned int i;



	/*

	 * A0: run

	 * A1: vcpu

	 */



	/* k0/k1 not being used in host kernel context */

	uasm_i_addiu(&p, K1, SP, -(int)sizeof(struct pt_regs));

	for (i = 16; i < 32; ++i) {

		if (i == 24)

			i = 28;

		UASM_i_SW(&p, i, offsetof(struct pt_regs, regs[i]), K1);

	}



	/* Save hi/lo */

	uasm_i_mflo(&p, V0);

	UASM_i_SW(&p, V0, offsetof(struct pt_regs, lo), K1);

	uasm_i_mfhi(&p, V1);

	UASM_i_SW(&p, V1, offsetof(struct pt_regs, hi), K1);



	/* Save host status */

	uasm_i_mfc0(&p, V0, C0_STATUS);

	UASM_i_SW(&p, V0, offsetof(struct pt_regs, cp0_status), K1);



	/* Save DDATA_LO, will be used to store pointer to vcpu */

	uasm_i_mfc0(&p, V1, C0_DDATA_LO);

	UASM_i_SW(&p, V1, offsetof(struct pt_regs, cp0_epc), K1);



	/* DDATA_LO has pointer to vcpu */

	uasm_i_mtc0(&p, A1, C0_DDATA_LO);



	/* Offset into vcpu->arch */

	uasm_i_addiu(&p, K1, A1, offsetof(struct kvm_vcpu, arch));



	/*

	 * Save the host stack to VCPU, used for exception processing

	 * when we exit from the Guest

	 */

	UASM_i_SW(&p, SP, offsetof(struct kvm_vcpu_arch, host_stack), K1);



	/* Save the kernel gp as well */

	UASM_i_SW(&p, GP, offsetof(struct kvm_vcpu_arch, host_gp), K1);



	/*

	 * Setup status register for running the guest in UM, interrupts

	 * are disabled

	 */

	UASM_i_LA(&p, K0, ST0_EXL | KSU_USER | ST0_BEV);

	uasm_i_mtc0(&p, K0, C0_STATUS);

	uasm_i_ehb(&p);



	/* load up the new EBASE */

	UASM_i_LW(&p, K0, offsetof(struct kvm_vcpu_arch, guest_ebase), K1);

	uasm_i_mtc0(&p, K0, C0_EBASE);



	/*

	 * Now that the new EBASE has been loaded, unset BEV, set

	 * interrupt mask as it was but make sure that timer interrupts

	 * are enabled

	 */

	uasm_i_addiu(&p, K0, ZERO, ST0_EXL | KSU_USER | ST0_IE);

	uasm_i_andi(&p, V0, V0, ST0_IM);

	uasm_i_or(&p, K0, K0, V0);

	uasm_i_mtc0(&p, K0, C0_STATUS);

	uasm_i_ehb(&p);



	p = kvm_mips_build_enter_guest(p);



	return p;

}



/**

 * kvm_mips_build_enter_guest() - Assemble code to resume guest execution.

 * @addr:	Address to start writing code.

 *

 * Assemble the code to resume guest execution. This code is common between the

 * initial entry into the guest from the host, and returning from the exit

 * handler back to the guest.

 *

 * Returns:	Next address after end of written function.

 */

static void *kvm_mips_build_enter_guest(void *addr)

{

	u32 *p = addr;

	unsigned int i;

	struct uasm_label labels[2];

	struct uasm_reloc relocs[2];

	struct uasm_label *l = labels;

	struct uasm_reloc *r = relocs;



	memset(labels, 0, sizeof(labels));

	memset(relocs, 0, sizeof(relocs));



	/* Set Guest EPC */

	UASM_i_LW(&p, T0, offsetof(struct kvm_vcpu_arch, pc), K1);

	uasm_i_mtc0(&p, T0, C0_EPC);



	/* Set the ASID for the Guest Kernel */

	UASM_i_LW(&p, T0, offsetof(struct kvm_vcpu_arch, cop0), K1);

	UASM_i_LW(&p, T0, offsetof(struct mips_coproc, reg[MIPS_CP0_STATUS][0]),

		  T0);

	uasm_i_andi(&p, T0, T0, KSU_USER | ST0_ERL | ST0_EXL);

	uasm_i_xori(&p, T0, T0, KSU_USER);

	uasm_il_bnez(&p, &r, T0, label_kernel_asid);

	 uasm_i_addiu(&p, T1, K1,

		      offsetof(struct kvm_vcpu_arch, guest_kernel_asid));

	/* else user */

	uasm_i_addiu(&p, T1, K1,

		     offsetof(struct kvm_vcpu_arch, guest_user_asid));

	uasm_l_kernel_asid(&l, p);



	/* t1: contains the base of the ASID array, need to get the cpu id  */

	/* smp_processor_id */

	UASM_i_LW(&p, T2, offsetof(struct thread_info, cpu), GP);

	/* x4 */

	uasm_i_sll(&p, T2, T2, 2);

	UASM_i_ADDU(&p, T3, T1, T2);

	UASM_i_LW(&p, K0, 0, T3);

#ifdef CONFIG_MIPS_ASID_BITS_VARIABLE

	/* x sizeof(struct cpuinfo_mips)/4 */

	uasm_i_addiu(&p, T3, ZERO, sizeof(struct cpuinfo_mips)/4);

	uasm_i_mul(&p, T2, T2, T3);



	UASM_i_LA_mostly(&p, AT, (long)&cpu_data[0].asid_mask);

	UASM_i_ADDU(&p, AT, AT, T2);

	UASM_i_LW(&p, T2, uasm_rel_lo((long)&cpu_data[0].asid_mask), AT);

	uasm_i_and(&p, K0, K0, T2);

#else

	uasm_i_andi(&p, K0, K0, MIPS_ENTRYHI_ASID);

#endif

	uasm_i_mtc0(&p, K0, C0_ENTRYHI);

	uasm_i_ehb(&p);



	/* Disable RDHWR access */

	uasm_i_mtc0(&p, ZERO, C0_HWRENA);



	/* load the guest context from VCPU and return */

	for (i = 1; i < 32; ++i) {

		/* Guest k0/k1 loaded later */

		if (i == K0 || i == K1)

			continue;

		UASM_i_LW(&p, i, offsetof(struct kvm_vcpu_arch, gprs[i]), K1);

	}



	/* Restore hi/lo */

	UASM_i_LW(&p, K0, offsetof(struct kvm_vcpu_arch, hi), K1);

	uasm_i_mthi(&p, K0);



	UASM_i_LW(&p, K0, offsetof(struct kvm_vcpu_arch, lo), K1);

	uasm_i_mtlo(&p, K0);



	/* Restore the guest's k0/k1 registers */

	UASM_i_LW(&p, K0, offsetof(struct kvm_vcpu_arch, gprs[K0]), K1);

	UASM_i_LW(&p, K1, offsetof(struct kvm_vcpu_arch, gprs[K1]), K1);



	/* Jump to guest */

	uasm_i_eret(&p);



	uasm_resolve_relocs(relocs, labels);



	return p;

}



/**

 * kvm_mips_build_exception() - Assemble first level guest exception handler.

 * @addr:	Address to start writing code.

 *

 * Assemble exception vector code for guest execution. The generated vector will

 * jump to the common exception handler generated by kvm_mips_build_exit().

 *

 * Returns:	Next address after end of written function.

 */

void *kvm_mips_build_exception(void *addr)

{

	u32 *p = addr;



	/* Save guest k0 */

	uasm_i_mtc0(&p, K0, C0_ERROREPC);

	uasm_i_ehb(&p);



	/* Get EBASE */

	uasm_i_mfc0(&p, K0, C0_EBASE);

	/* Get rid of CPUNum */

	uasm_i_srl(&p, K0, K0, 10);

	uasm_i_sll(&p, K0, K0, 10);

	/* Save k1 @ offset 0x3000 */

	UASM_i_SW(&p, K1, 0x3000, K0);



	/* Exception handler is installed @ offset 0x2000 */

	uasm_i_addiu(&p, K0, K0, 0x2000);

	/* Jump to the function */

	uasm_i_jr(&p, K0);

	 uasm_i_nop(&p);



	return p;

}



/**

 * kvm_mips_build_exit() - Assemble common guest exit handler.

 * @addr:	Address to start writing code.

 *

 * Assemble the generic guest exit handling code. This is called by the

 * exception vectors (generated by kvm_mips_build_exception()), and calls

 * kvm_mips_handle_exit(), then either resumes the guest or returns to the host

 * depending on the return value.

 *

 * Returns:	Next address after end of written function.

 */

void *kvm_mips_build_exit(void *addr)

{

	u32 *p = addr;

	unsigned int i;

	struct uasm_label labels[3];

	struct uasm_reloc relocs[3];

	struct uasm_label *l = labels;

	struct uasm_reloc *r = relocs;



	memset(labels, 0, sizeof(labels));

	memset(relocs, 0, sizeof(relocs));



	/*

	 * Generic Guest exception handler. We end up here when the guest

	 * does something that causes a trap to kernel mode.

	 */



	/* Get the VCPU pointer from DDATA_LO */

	uasm_i_mfc0(&p, K1, C0_DDATA_LO);

	uasm_i_addiu(&p, K1, K1, offsetof(struct kvm_vcpu, arch));



	/* Start saving Guest context to VCPU */

	for (i = 0; i < 32; ++i) {

		/* Guest k0/k1 saved later */

		if (i == K0 || i == K1)

			continue;

		UASM_i_SW(&p, i, offsetof(struct kvm_vcpu_arch, gprs[i]), K1);

	}



	/* We need to save hi/lo and restore them on the way out */

	uasm_i_mfhi(&p, T0);

	UASM_i_SW(&p, T0, offsetof(struct kvm_vcpu_arch, hi), K1);



	uasm_i_mflo(&p, T0);

	UASM_i_SW(&p, T0, offsetof(struct kvm_vcpu_arch, lo), K1);



	/* Finally save guest k0/k1 to VCPU */

	uasm_i_mfc0(&p, T0, C0_ERROREPC);

	UASM_i_SW(&p, T0, offsetof(struct kvm_vcpu_arch, gprs[K0]), K1);



	/* Get GUEST k1 and save it in VCPU */

	uasm_i_addiu(&p, T1, ZERO, ~0x2ff);

	uasm_i_mfc0(&p, T0, C0_EBASE);

	uasm_i_and(&p, T0, T0, T1);

	UASM_i_LW(&p, T0, 0x3000, T0);

	UASM_i_SW(&p, T0, offsetof(struct kvm_vcpu_arch, gprs[K1]), K1);



	/* Now that context has been saved, we can use other registers */



	/* Restore vcpu */

	uasm_i_mfc0(&p, A1, C0_DDATA_LO);

	uasm_i_move(&p, S1, A1);



	/* Restore run (vcpu->run) */

	UASM_i_LW(&p, A0, offsetof(struct kvm_vcpu, run), A1);

	/* Save pointer to run in s0, will be saved by the compiler */

	uasm_i_move(&p, S0, A0);



	/*

	 * Save Host level EPC, BadVaddr and Cause to VCPU, useful to process

	 * the exception

	 */

	uasm_i_mfc0(&p, K0, C0_EPC);

	UASM_i_SW(&p, K0, offsetof(struct kvm_vcpu_arch, pc), K1);



	uasm_i_mfc0(&p, K0, C0_BADVADDR);

	UASM_i_SW(&p, K0, offsetof(struct kvm_vcpu_arch, host_cp0_badvaddr),

		  K1);



	uasm_i_mfc0(&p, K0, C0_CAUSE);

	uasm_i_sw(&p, K0, offsetof(struct kvm_vcpu_arch, host_cp0_cause), K1);



	/* Now restore the host state just enough to run the handlers */



	/* Switch EBASE to the one used by Linux */

	/* load up the host EBASE */

	uasm_i_mfc0(&p, V0, C0_STATUS);



	uasm_i_lui(&p, AT, ST0_BEV >> 16);

	uasm_i_or(&p, K0, V0, AT);



	uasm_i_mtc0(&p, K0, C0_STATUS);

	uasm_i_ehb(&p);



	UASM_i_LA_mostly(&p, K0, (long)&ebase);

	UASM_i_LW(&p, K0, uasm_rel_lo((long)&ebase), K0);

	uasm_i_mtc0(&p, K0, C0_EBASE);



	/*

	 * If FPU is enabled, save FCR31 and clear it so that later ctc1's don't

	 * trigger FPE for pending exceptions.

	 */

	uasm_i_lui(&p, AT, ST0_CU1 >> 16);

	uasm_i_and(&p, V1, V0, AT);

	uasm_il_beqz(&p, &r, V1, label_fpu_1);

	 uasm_i_nop(&p);

	uasm_i_cfc1(&p, T0, 31);

	uasm_i_sw(&p, T0, offsetof(struct kvm_vcpu_arch, fpu.fcr31), K1);

	uasm_i_ctc1(&p, ZERO, 31);

	uasm_l_fpu_1(&l, p);



#ifdef CONFIG_CPU_HAS_MSA

	/*

	 * If MSA is enabled, save MSACSR and clear it so that later

	 * instructions don't trigger MSAFPE for pending exceptions.

	 */

	uasm_i_mfc0(&p, T0, C0_CONFIG3);

	uasm_i_ext(&p, T0, T0, 28, 1); /* MIPS_CONF3_MSAP */

	uasm_il_beqz(&p, &r, T0, label_msa_1);

	 uasm_i_nop(&p);

	uasm_i_mfc0(&p, T0, C0_CONFIG5);

	uasm_i_ext(&p, T0, T0, 27, 1); /* MIPS_CONF5_MSAEN */

	uasm_il_beqz(&p, &r, T0, label_msa_1);

	 uasm_i_nop(&p);

	uasm_i_cfcmsa(&p, T0, MSA_CSR);

	uasm_i_sw(&p, T0, offsetof(struct kvm_vcpu_arch, fpu.msacsr),

		  K1);

	uasm_i_ctcmsa(&p, MSA_CSR, ZERO);

	uasm_l_msa_1(&l, p);

#endif



	/* Now that the new EBASE has been loaded, unset BEV and KSU_USER */

	uasm_i_addiu(&p, AT, ZERO, ~(ST0_EXL | KSU_USER | ST0_IE));

	uasm_i_and(&p, V0, V0, AT);

	uasm_i_lui(&p, AT, ST0_CU0 >> 16);

	uasm_i_or(&p, V0, V0, AT);

	uasm_i_mtc0(&p, V0, C0_STATUS);

	uasm_i_ehb(&p);



	/* Load up host GP */

	UASM_i_LW(&p, GP, offsetof(struct kvm_vcpu_arch, host_gp), K1);



	/* Need a stack before we can jump to "C" */

	UASM_i_LW(&p, SP, offsetof(struct kvm_vcpu_arch, host_stack), K1);



	/* Saved host state */

	uasm_i_addiu(&p, SP, SP, -(int)sizeof(struct pt_regs));



	/*

	 * XXXKYMA do we need to load the host ASID, maybe not because the

	 * kernel entries are marked GLOBAL, need to verify

	 */



	/* Restore host DDATA_LO */

	UASM_i_LW(&p, K0, offsetof(struct pt_regs, cp0_epc), SP);

	uasm_i_mtc0(&p, K0, C0_DDATA_LO);



	/* Restore RDHWR access */

	UASM_i_LA_mostly(&p, K0, (long)&hwrena);

	uasm_i_lw(&p, K0, uasm_rel_lo((long)&hwrena), K0);

	uasm_i_mtc0(&p, K0, C0_HWRENA);



	/* Jump to handler */

	/*

	 * XXXKYMA: not sure if this is safe, how large is the stack??

	 * Now jump to the kvm_mips_handle_exit() to see if we can deal

	 * with this in the kernel

	 */

	UASM_i_LA(&p, T9, (unsigned long)kvm_mips_handle_exit);

	uasm_i_jalr(&p, RA, T9);

	 uasm_i_addiu(&p, SP, SP, -CALLFRAME_SIZ);



	uasm_resolve_relocs(relocs, labels);



	p = kvm_mips_build_ret_from_exit(p);



	return p;

}



/**

 * kvm_mips_build_ret_from_exit() - Assemble guest exit return handler.

 * @addr:	Address to start writing code.

 *

 * Assemble the code to handle the return from kvm_mips_handle_exit(), either

 * resuming the guest or returning to the host depending on the return value.

 *

 * Returns:	Next address after end of written function.

 */

static void *kvm_mips_build_ret_from_exit(void *addr)

{

	u32 *p = addr;

	struct uasm_label labels[2];

	struct uasm_reloc relocs[2];

	struct uasm_label *l = labels;

	struct uasm_reloc *r = relocs;



	memset(labels, 0, sizeof(labels));

	memset(relocs, 0, sizeof(relocs));



	/* Return from handler Make sure interrupts are disabled */

	uasm_i_di(&p, ZERO);

	uasm_i_ehb(&p);



	/*

	 * XXXKYMA: k0/k1 could have been blown away if we processed

	 * an exception while we were handling the exception from the

	 * guest, reload k1

	 */



	uasm_i_move(&p, K1, S1);

	uasm_i_addiu(&p, K1, K1, offsetof(struct kvm_vcpu, arch));



	/*

	 * Check return value, should tell us if we are returning to the

	 * host (handle I/O etc)or resuming the guest

	 */

	uasm_i_andi(&p, T0, V0, RESUME_HOST);

	uasm_il_bnez(&p, &r, T0, label_return_to_host);

	 uasm_i_nop(&p);



	p = kvm_mips_build_ret_to_guest(p);



	uasm_l_return_to_host(&l, p);

	p = kvm_mips_build_ret_to_host(p);



	uasm_resolve_relocs(relocs, labels);



	return p;

}



/**

 * kvm_mips_build_ret_to_guest() - Assemble code to return to the guest.

 * @addr:	Address to start writing code.

 *

 * Assemble the code to handle return from the guest exit handler

 * (kvm_mips_handle_exit()) back to the guest.

 *

 * Returns:	Next address after end of written function.

 */

static void *kvm_mips_build_ret_to_guest(void *addr)

{

	u32 *p = addr;



	/* Put the saved pointer to vcpu (s1) back into the DDATA_LO Register */

	uasm_i_mtc0(&p, S1, C0_DDATA_LO);



	/* Load up the Guest EBASE to minimize the window where BEV is set */

	UASM_i_LW(&p, T0, offsetof(struct kvm_vcpu_arch, guest_ebase), K1);



	/* Switch EBASE back to the one used by KVM */

	uasm_i_mfc0(&p, V1, C0_STATUS);

	uasm_i_lui(&p, AT, ST0_BEV >> 16);

	uasm_i_or(&p, K0, V1, AT);

	uasm_i_mtc0(&p, K0, C0_STATUS);

	uasm_i_ehb(&p);

	uasm_i_mtc0(&p, T0, C0_EBASE);



	/* Setup status register for running guest in UM */

	uasm_i_ori(&p, V1, V1, ST0_EXL | KSU_USER | ST0_IE);

	UASM_i_LA(&p, AT, ~(ST0_CU0 | ST0_MX));

	uasm_i_and(&p, V1, V1, AT);

	uasm_i_mtc0(&p, V1, C0_STATUS);

	uasm_i_ehb(&p);



	p = kvm_mips_build_enter_guest(p);



	return p;

}



/**

 * kvm_mips_build_ret_to_host() - Assemble code to return to the host.

 * @addr:	Address to start writing code.

 *

 * Assemble the code to handle return from the guest exit handler

 * (kvm_mips_handle_exit()) back to the host, i.e. to the caller of the vcpu_run

 * function generated by kvm_mips_build_vcpu_run().

 *

 * Returns:	Next address after end of written function.

 */

static void *kvm_mips_build_ret_to_host(void *addr)

{

	u32 *p = addr;

	unsigned int i;



	/* EBASE is already pointing to Linux */

	UASM_i_LW(&p, K1, offsetof(struct kvm_vcpu_arch, host_stack), K1);

	uasm_i_addiu(&p, K1, K1, -(int)sizeof(struct pt_regs));



	/* Restore host DDATA_LO */

	UASM_i_LW(&p, K0, offsetof(struct pt_regs, cp0_epc), K1);

	uasm_i_mtc0(&p, K0, C0_DDATA_LO);



	/*

	 * r2/v0 is the return code, shift it down by 2 (arithmetic)

	 * to recover the err code

	 */

	uasm_i_sra(&p, K0, V0, 2);

	uasm_i_move(&p, V0, K0);



	/* Load context saved on the host stack */

	for (i = 16; i < 31; ++i) {

		if (i == 24)

			i = 28;

		UASM_i_LW(&p, i, offsetof(struct pt_regs, regs[i]), K1);

	}



	UASM_i_LW(&p, K0, offsetof(struct pt_regs, hi), K1);

	uasm_i_mthi(&p, K0);



	UASM_i_LW(&p, K0, offsetof(struct pt_regs, lo), K1);

	uasm_i_mtlo(&p, K0);



	/* Restore RDHWR access */

	UASM_i_LA_mostly(&p, K0, (long)&hwrena);

	uasm_i_lw(&p, K0, uasm_rel_lo((long)&hwrena), K0);

	uasm_i_mtc0(&p, K0, C0_HWRENA);



	/* Restore RA, which is the address we will return to */

	UASM_i_LW(&p, RA, offsetof(struct pt_regs, regs[RA]), K1);

	uasm_i_jr(&p, RA);

	 uasm_i_nop(&p);



	return p;

}

arch/mips/kvm/interrupt.h

+0 −4
Original line number Diff line number Diff line
@@ -28,10 +28,6 @@ 
#define MIPS_EXC_MAX                12

/* XXXSL More to follow */



extern char __kvm_mips_vcpu_run_end[];

extern char mips32_exception[], mips32_exceptionEnd[];

extern char mips32_GuestException[], mips32_GuestExceptionEnd[];



#define C_TI        (_ULCAST_(1) << 30)



#define KVM_MIPS_IRQ_DELIVER_ALL_AT_ONCE (0)

CRA Git | Maintained and supported by SUSTech CRA and CCSE