Merge tag 'kvm-s390-master-4.16-1' of... (722c2cd7) · Commits · 戴 / test

arch/s390/kvm/intercept.c

+29 −22

Original line number	Diff line number	Diff line
		@@ -22,22 +22,6 @@
		#include "trace.h"
		#include "trace-s390.h"


		static const intercept_handler_t instruction_handlers[256] = {
		[0x01] = kvm_s390_handle_01,
		[0x82] = kvm_s390_handle_lpsw,
		[0x83] = kvm_s390_handle_diag,
		[0xaa] = kvm_s390_handle_aa,
		[0xae] = kvm_s390_handle_sigp,
		[0xb2] = kvm_s390_handle_b2,
		[0xb6] = kvm_s390_handle_stctl,
		[0xb7] = kvm_s390_handle_lctl,
		[0xb9] = kvm_s390_handle_b9,
		[0xe3] = kvm_s390_handle_e3,
		[0xe5] = kvm_s390_handle_e5,
		[0xeb] = kvm_s390_handle_eb,
		};

		u8 kvm_s390_get_ilen(struct kvm_vcpu *vcpu)
		{
		struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;
		@@ -129,17 +113,40 @@ static int handle_validity(struct kvm_vcpu *vcpu)

		static int handle_instruction(struct kvm_vcpu *vcpu)
		{
		intercept_handler_t handler;

		vcpu->stat.exit_instruction++;
		trace_kvm_s390_intercept_instruction(vcpu,
		vcpu->arch.sie_block->ipa,
		vcpu->arch.sie_block->ipb);
		handler = instruction_handlers[vcpu->arch.sie_block->ipa >> 8];
		if (handler)
		return handler(vcpu);

		switch (vcpu->arch.sie_block->ipa >> 8) {
		case 0x01:
		return kvm_s390_handle_01(vcpu);
		case 0x82:
		return kvm_s390_handle_lpsw(vcpu);
		case 0x83:
		return kvm_s390_handle_diag(vcpu);
		case 0xaa:
		return kvm_s390_handle_aa(vcpu);
		case 0xae:
		return kvm_s390_handle_sigp(vcpu);
		case 0xb2:
		return kvm_s390_handle_b2(vcpu);
		case 0xb6:
		return kvm_s390_handle_stctl(vcpu);
		case 0xb7:
		return kvm_s390_handle_lctl(vcpu);
		case 0xb9:
		return kvm_s390_handle_b9(vcpu);
		case 0xe3:
		return kvm_s390_handle_e3(vcpu);
		case 0xe5:
		return kvm_s390_handle_e5(vcpu);
		case 0xeb:
		return kvm_s390_handle_eb(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

		static int inject_prog_on_prog_intercept(struct kvm_vcpu *vcpu)
		{

arch/s390/kvm/interrupt.c

+60 −38

Original line number	Diff line number	Diff line
		@@ -187,12 +187,6 @@ static int cpu_timer_irq_pending(struct kvm_vcpu *vcpu)
		return kvm_s390_get_cpu_timer(vcpu) >> 63;
		}

		static inline int is_ioirq(unsigned long irq_type)
		{
		return ((irq_type >= IRQ_PEND_IO_ISC_7) &&
		(irq_type <= IRQ_PEND_IO_ISC_0));
		}

		static uint64_t isc_to_isc_bits(int isc)
		{
		return (0x80 >> isc) << 24;
		@@ -236,10 +230,15 @@ static inline int kvm_s390_gisa_tac_ipm_gisc(struct kvm_s390_gisa *gisa, u32 gis
		return test_and_clear_bit_inv(IPM_BIT_OFFSET + gisc, (unsigned long *) gisa);
		}

		static inline unsigned long pending_irqs(struct kvm_vcpu *vcpu)
		static inline unsigned long pending_irqs_no_gisa(struct kvm_vcpu *vcpu)
		{
		return vcpu->kvm->arch.float_int.pending_irqs \|
		vcpu->arch.local_int.pending_irqs \|
		vcpu->arch.local_int.pending_irqs;
		}

		static inline unsigned long pending_irqs(struct kvm_vcpu *vcpu)
		{
		return pending_irqs_no_gisa(vcpu) \|
		kvm_s390_gisa_get_ipm(vcpu->kvm->arch.gisa) << IRQ_PEND_IO_ISC_7;
		}

		@@ -337,7 +336,7 @@ static void __reset_intercept_indicators(struct kvm_vcpu *vcpu)

		static void set_intercept_indicators_io(struct kvm_vcpu *vcpu)
		{
		if (!(pending_irqs(vcpu) & IRQ_PEND_IO_MASK))
		if (!(pending_irqs_no_gisa(vcpu) & IRQ_PEND_IO_MASK))
		return;
		else if (psw_ioint_disabled(vcpu))
		kvm_s390_set_cpuflags(vcpu, CPUSTAT_IO_INT);
		@@ -1011,24 +1010,6 @@ out:
		return rc;
		}

		typedef int (deliver_irq_t)(struct kvm_vcpu vcpu);

		static const deliver_irq_t deliver_irq_funcs[] = {
		[IRQ_PEND_MCHK_EX] = __deliver_machine_check,
		[IRQ_PEND_MCHK_REP] = __deliver_machine_check,
		[IRQ_PEND_PROG] = __deliver_prog,
		[IRQ_PEND_EXT_EMERGENCY] = __deliver_emergency_signal,
		[IRQ_PEND_EXT_EXTERNAL] = __deliver_external_call,
		[IRQ_PEND_EXT_CLOCK_COMP] = __deliver_ckc,
		[IRQ_PEND_EXT_CPU_TIMER] = __deliver_cpu_timer,
		[IRQ_PEND_RESTART] = __deliver_restart,
		[IRQ_PEND_SET_PREFIX] = __deliver_set_prefix,
		[IRQ_PEND_PFAULT_INIT] = __deliver_pfault_init,
		[IRQ_PEND_EXT_SERVICE] = __deliver_service,
		[IRQ_PEND_PFAULT_DONE] = __deliver_pfault_done,
		[IRQ_PEND_VIRTIO] = __deliver_virtio,
		};

		/* Check whether an external call is pending (deliverable or not) */
		int kvm_s390_ext_call_pending(struct kvm_vcpu *vcpu)
		{
		@@ -1192,7 +1173,6 @@ void kvm_s390_clear_local_irqs(struct kvm_vcpu *vcpu)
		int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
		{
		struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
		deliver_irq_t func;
		int rc = 0;
		unsigned long irq_type;
		unsigned long irqs;
		@@ -1212,16 +1192,57 @@ int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
		while ((irqs = deliverable_irqs(vcpu)) && !rc) {
		/* bits are in the reverse order of interrupt priority */
		irq_type = find_last_bit(&irqs, IRQ_PEND_COUNT);
		if (is_ioirq(irq_type)) {
		switch (irq_type) {
		case IRQ_PEND_IO_ISC_0:
		case IRQ_PEND_IO_ISC_1:
		case IRQ_PEND_IO_ISC_2:
		case IRQ_PEND_IO_ISC_3:
		case IRQ_PEND_IO_ISC_4:
		case IRQ_PEND_IO_ISC_5:
		case IRQ_PEND_IO_ISC_6:
		case IRQ_PEND_IO_ISC_7:
		rc = __deliver_io(vcpu, irq_type);
		} else {
		func = deliver_irq_funcs[irq_type];
		if (!func) {
		WARN_ON_ONCE(func == NULL);
		break;
		case IRQ_PEND_MCHK_EX:
		case IRQ_PEND_MCHK_REP:
		rc = __deliver_machine_check(vcpu);
		break;
		case IRQ_PEND_PROG:
		rc = __deliver_prog(vcpu);
		break;
		case IRQ_PEND_EXT_EMERGENCY:
		rc = __deliver_emergency_signal(vcpu);
		break;
		case IRQ_PEND_EXT_EXTERNAL:
		rc = __deliver_external_call(vcpu);
		break;
		case IRQ_PEND_EXT_CLOCK_COMP:
		rc = __deliver_ckc(vcpu);
		break;
		case IRQ_PEND_EXT_CPU_TIMER:
		rc = __deliver_cpu_timer(vcpu);
		break;
		case IRQ_PEND_RESTART:
		rc = __deliver_restart(vcpu);
		break;
		case IRQ_PEND_SET_PREFIX:
		rc = __deliver_set_prefix(vcpu);
		break;
		case IRQ_PEND_PFAULT_INIT:
		rc = __deliver_pfault_init(vcpu);
		break;
		case IRQ_PEND_EXT_SERVICE:
		rc = __deliver_service(vcpu);
		break;
		case IRQ_PEND_PFAULT_DONE:
		rc = __deliver_pfault_done(vcpu);
		break;
		case IRQ_PEND_VIRTIO:
		rc = __deliver_virtio(vcpu);
		break;
		default:
		WARN_ONCE(1, "Unknown pending irq type %ld", irq_type);
		clear_bit(irq_type, &li->pending_irqs);
		continue;
		}
		rc = func(vcpu);
		}
		}

		@@ -1701,6 +1722,7 @@ static void __floating_irq_kick(struct kvm *kvm, u64 type)
		kvm_s390_set_cpuflags(dst_vcpu, CPUSTAT_STOP_INT);
		break;
		case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:
		if (!(type & KVM_S390_INT_IO_AI_MASK && kvm->arch.gisa))
		kvm_s390_set_cpuflags(dst_vcpu, CPUSTAT_IO_INT);
		break;
		default:

arch/s390/kvm/kvm-s390.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -19,8 +19,6 @@
		#include <asm/processor.h>
		#include <asm/sclp.h>

		typedef int (intercept_handler_t)(struct kvm_vcpu vcpu);

		/* Transactional Memory Execution related macros */
		#define IS_TE_ENABLED(vcpu) ((vcpu->arch.sie_block->ecb & ECB_TE))
		#define TDB_FORMAT1 1

arch/s390/kvm/priv.c

+91 −92

Original line number	Diff line number	Diff line
		@@ -795,56 +795,61 @@ out:
		return rc;
		}

		static const intercept_handler_t b2_handlers[256] = {
		[0x02] = handle_stidp,
		[0x04] = handle_set_clock,
		[0x10] = handle_set_prefix,
		[0x11] = handle_store_prefix,
		[0x12] = handle_store_cpu_address,
		[0x14] = kvm_s390_handle_vsie,
		[0x21] = handle_ipte_interlock,
		[0x29] = handle_iske,
		[0x2a] = handle_rrbe,
		[0x2b] = handle_sske,
		[0x2c] = handle_test_block,
		[0x30] = handle_io_inst,
		[0x31] = handle_io_inst,
		[0x32] = handle_io_inst,
		[0x33] = handle_io_inst,
		[0x34] = handle_io_inst,
		[0x35] = handle_io_inst,
		[0x36] = handle_io_inst,
		[0x37] = handle_io_inst,
		[0x38] = handle_io_inst,
		[0x39] = handle_io_inst,
		[0x3a] = handle_io_inst,
		[0x3b] = handle_io_inst,
		[0x3c] = handle_io_inst,
		[0x50] = handle_ipte_interlock,
		[0x56] = handle_sthyi,
		[0x5f] = handle_io_inst,
		[0x74] = handle_io_inst,
		[0x76] = handle_io_inst,
		[0x7d] = handle_stsi,
		[0xb1] = handle_stfl,
		[0xb2] = handle_lpswe,
		};

		int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
		{
		intercept_handler_t handler;

		/*
		* A lot of B2 instructions are priviledged. Here we check for
		* the privileged ones, that we can handle in the kernel.
		* Anything else goes to userspace.
		*/
		handler = b2_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
		if (handler)
		return handler(vcpu);

		switch (vcpu->arch.sie_block->ipa & 0x00ff) {
		case 0x02:
		return handle_stidp(vcpu);
		case 0x04:
		return handle_set_clock(vcpu);
		case 0x10:
		return handle_set_prefix(vcpu);
		case 0x11:
		return handle_store_prefix(vcpu);
		case 0x12:
		return handle_store_cpu_address(vcpu);
		case 0x14:
		return kvm_s390_handle_vsie(vcpu);
		case 0x21:
		case 0x50:
		return handle_ipte_interlock(vcpu);
		case 0x29:
		return handle_iske(vcpu);
		case 0x2a:
		return handle_rrbe(vcpu);
		case 0x2b:
		return handle_sske(vcpu);
		case 0x2c:
		return handle_test_block(vcpu);
		case 0x30:
		case 0x31:
		case 0x32:
		case 0x33:
		case 0x34:
		case 0x35:
		case 0x36:
		case 0x37:
		case 0x38:
		case 0x39:
		case 0x3a:
		case 0x3b:
		case 0x3c:
		case 0x5f:
		case 0x74:
		case 0x76:
		return handle_io_inst(vcpu);
		case 0x56:
		return handle_sthyi(vcpu);
		case 0x7d:
		return handle_stsi(vcpu);
		case 0xb1:
		return handle_stfl(vcpu);
		case 0xb2:
		return handle_lpswe(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

		static int handle_epsw(struct kvm_vcpu *vcpu)
		{
		@@ -1105,26 +1110,23 @@ static int handle_essa(struct kvm_vcpu *vcpu)
		return 0;
		}

		static const intercept_handler_t b9_handlers[256] = {
		[0x8a] = handle_ipte_interlock,
		[0x8d] = handle_epsw,
		[0x8e] = handle_ipte_interlock,
		[0x8f] = handle_ipte_interlock,
		[0xab] = handle_essa,
		[0xaf] = handle_pfmf,
		};

		int kvm_s390_handle_b9(struct kvm_vcpu *vcpu)
		{
		intercept_handler_t handler;

		/* This is handled just as for the B2 instructions. */
		handler = b9_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
		if (handler)
		return handler(vcpu);

		switch (vcpu->arch.sie_block->ipa & 0x00ff) {
		case 0x8a:
		case 0x8e:
		case 0x8f:
		return handle_ipte_interlock(vcpu);
		case 0x8d:
		return handle_epsw(vcpu);
		case 0xab:
		return handle_essa(vcpu);
		case 0xaf:
		return handle_pfmf(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

		int kvm_s390_handle_lctl(struct kvm_vcpu *vcpu)
		{
		@@ -1271,23 +1273,21 @@ static int handle_stctg(struct kvm_vcpu *vcpu)
		return rc ? kvm_s390_inject_prog_cond(vcpu, rc) : 0;
		}

		static const intercept_handler_t eb_handlers[256] = {
		[0x2f] = handle_lctlg,
		[0x25] = handle_stctg,
		[0x60] = handle_ri,
		[0x61] = handle_ri,
		[0x62] = handle_ri,
		};

		int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)
		{
		intercept_handler_t handler;

		handler = eb_handlers[vcpu->arch.sie_block->ipb & 0xff];
		if (handler)
		return handler(vcpu);
		switch (vcpu->arch.sie_block->ipb & 0x000000ff) {
		case 0x25:
		return handle_stctg(vcpu);
		case 0x2f:
		return handle_lctlg(vcpu);
		case 0x60:
		case 0x61:
		case 0x62:
		return handle_ri(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

		static int handle_tprot(struct kvm_vcpu *vcpu)
		{
		@@ -1346,11 +1346,13 @@ out_unlock:

		int kvm_s390_handle_e5(struct kvm_vcpu *vcpu)
		{
		/* For e5xx... instructions we only handle TPROT */
		if ((vcpu->arch.sie_block->ipa & 0x00ff) == 0x01)
		switch (vcpu->arch.sie_block->ipa & 0x00ff) {
		case 0x01:
		return handle_tprot(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

		static int handle_sckpf(struct kvm_vcpu *vcpu)
		{
		@@ -1380,17 +1382,14 @@ static int handle_ptff(struct kvm_vcpu *vcpu)
		return 0;
		}

		static const intercept_handler_t x01_handlers[256] = {
		[0x04] = handle_ptff,
		[0x07] = handle_sckpf,
		};

		int kvm_s390_handle_01(struct kvm_vcpu *vcpu)
		{
		intercept_handler_t handler;

		handler = x01_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
		if (handler)
		return handler(vcpu);
		switch (vcpu->arch.sie_block->ipa & 0x00ff) {
		case 0x04:
		return handle_ptff(vcpu);
		case 0x07:
		return handle_sckpf(vcpu);
		default:
		return -EOPNOTSUPP;
		}
		}

arch/s390/kvm/vsie.c

+20 −0

Original line number	Diff line number	Diff line
		@@ -821,6 +821,7 @@ static int do_vsie_run(struct kvm_vcpu vcpu, struct vsie_page vsie_page)
		{
		struct kvm_s390_sie_block *scb_s = &vsie_page->scb_s;
		struct kvm_s390_sie_block *scb_o = vsie_page->scb_o;
		int guest_bp_isolation;
		int rc;

		handle_last_fault(vcpu, vsie_page);
		@@ -831,6 +832,20 @@ static int do_vsie_run(struct kvm_vcpu vcpu, struct vsie_page vsie_page)
		s390_handle_mcck();

		srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);

		/* save current guest state of bp isolation override */
		guest_bp_isolation = test_thread_flag(TIF_ISOLATE_BP_GUEST);

		/*
		* The guest is running with BPBC, so we have to force it on for our
		* nested guest. This is done by enabling BPBC globally, so the BPBC
		* control in the SCB (which the nested guest can modify) is simply
		* ignored.
		*/
		if (test_kvm_facility(vcpu->kvm, 82) &&
		vcpu->arch.sie_block->fpf & FPF_BPBC)
		set_thread_flag(TIF_ISOLATE_BP_GUEST);

		local_irq_disable();
		guest_enter_irqoff();
		local_irq_enable();
		@@ -840,6 +855,11 @@ static int do_vsie_run(struct kvm_vcpu vcpu, struct vsie_page vsie_page)
		local_irq_disable();
		guest_exit_irqoff();
		local_irq_enable();

		/* restore guest state for bp isolation override */
		if (!guest_bp_isolation)
		clear_thread_flag(TIF_ISOLATE_BP_GUEST);

		vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);

		if (rc == -EINTR) {

Admin message