Merge tag 'kvm-s390-20131128' of... (d6d63b51) · Commits · 戴 / test

arch/s390/kvm/diag.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -137,7 +137,7 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)

	int kvm_s390_handle_diag(struct kvm_vcpu *vcpu)		int kvm_s390_handle_diag(struct kvm_vcpu *vcpu)
	{		{
	int code = (vcpu->arch.sie_block->ipb & 0xfff0000) >> 16;		int code = kvm_s390_get_base_disp_rs(vcpu) & 0xffff;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)		if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
	return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

arch/s390/kvm/kvm-s390.c

+24 −29

Original line number	Original line	Diff line number	Diff line
	@@ -732,14 +732,12 @@ static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)

	if (exit_reason >= 0) {		if (exit_reason >= 0) {
	rc = 0;		rc = 0;
	} else {		} else if (kvm_is_ucontrol(vcpu->kvm)) {
	if (kvm_is_ucontrol(vcpu->kvm)) {		vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
	rc = SIE_INTERCEPT_UCONTROL;		vcpu->run->s390_ucontrol.trans_exc_code =
	} else {		current->thread.gmap_addr;
	VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");		vcpu->run->s390_ucontrol.pgm_code = 0x10;
	trace_kvm_s390_sie_fault(vcpu);		rc = -EREMOTE;
	rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
	}
	}		}

	memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);		memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
	@@ -833,16 +831,6 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run)
	rc = -EINTR;		rc = -EINTR;
	}		}

	#ifdef CONFIG_KVM_S390_UCONTROL
	if (rc == SIE_INTERCEPT_UCONTROL) {
	kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
	kvm_run->s390_ucontrol.trans_exc_code =
	current->thread.gmap_addr;
	kvm_run->s390_ucontrol.pgm_code = 0x10;
	rc = 0;
	}
	#endif

	if (rc == -EOPNOTSUPP) {		if (rc == -EOPNOTSUPP) {
	/* intercept cannot be handled in-kernel, prepare kvm-run */		/* intercept cannot be handled in-kernel, prepare kvm-run */
	kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;		kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
	@@ -885,10 +873,11 @@ static int __guestcopy(struct kvm_vcpu vcpu, u64 guestdest, void from,
	* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit		* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
	* KVM_S390_STORE_STATUS_PREFIXED: -> prefix		* KVM_S390_STORE_STATUS_PREFIXED: -> prefix
	*/		*/
	int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)		int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
	{		{
	unsigned char archmode = 1;		unsigned char archmode = 1;
	int prefix;		int prefix;
			u64 clkcomp;

	if (addr == KVM_S390_STORE_STATUS_NOADDR) {		if (addr == KVM_S390_STORE_STATUS_NOADDR) {
	if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))		if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
	@@ -903,15 +892,6 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
	} else		} else
	prefix = 0;		prefix = 0;

	/*
	* The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
	* copying in vcpu load/put. Lets update our copies before we save
	* it into the save area
	*/
	save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	save_fp_regs(vcpu->arch.guest_fpregs.fprs);
	save_access_regs(vcpu->run->s.regs.acrs);

	if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),		if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
	vcpu->arch.guest_fpregs.fprs, 128, prefix))		vcpu->arch.guest_fpregs.fprs, 128, prefix))
	return -EFAULT;		return -EFAULT;
	@@ -941,8 +921,9 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
	&vcpu->arch.sie_block->cputm, 8, prefix))		&vcpu->arch.sie_block->cputm, 8, prefix))
	return -EFAULT;		return -EFAULT;

			clkcomp = vcpu->arch.sie_block->ckc >> 8;
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),		if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
	&vcpu->arch.sie_block->ckc, 8, prefix))		&clkcomp, 8, prefix))
	return -EFAULT;		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),		if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
	@@ -956,6 +937,20 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
	return 0;		return 0;
	}		}

			int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
			{
			/*
			* The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
			* copying in vcpu load/put. Lets update our copies before we save
			* it into the save area
			*/
			save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
			save_fp_regs(vcpu->arch.guest_fpregs.fprs);
			save_access_regs(vcpu->run->s.regs.acrs);

			return kvm_s390_store_status_unloaded(vcpu, addr);
			}

	static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,		static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
	struct kvm_enable_cap *cap)		struct kvm_enable_cap *cap)
	{		{

arch/s390/kvm/kvm-s390.h

+2 −8

Original line number	Original line	Diff line number	Diff line
	@@ -19,16 +19,11 @@
	#include <linux/kvm.h>		#include <linux/kvm.h>
	#include <linux/kvm_host.h>		#include <linux/kvm_host.h>

	/* The current code can have up to 256 pages for virtio */
	#define VIRTIODESCSPACE (256ul * 4096ul)

	typedef int (intercept_handler_t)(struct kvm_vcpu vcpu);		typedef int (intercept_handler_t)(struct kvm_vcpu vcpu);

	/* declare vfacilities extern */		/* declare vfacilities extern */
	extern unsigned long *vfacilities;		extern unsigned long *vfacilities;

	/* negativ values are error codes, positive values for internal conditions */
	#define SIE_INTERCEPT_UCONTROL (1<<0)
	int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu);		int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu);

	#define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\		#define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\
	@@ -133,7 +128,6 @@ int __must_check kvm_s390_inject_vm(struct kvm *kvm,
	int __must_check kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,		int __must_check kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
	struct kvm_s390_interrupt *s390int);		struct kvm_s390_interrupt *s390int);
	int __must_check kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code);		int __must_check kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code);
	int __must_check kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action);
	struct kvm_s390_interrupt_info kvm_s390_get_io_int(struct kvm kvm,		struct kvm_s390_interrupt_info kvm_s390_get_io_int(struct kvm kvm,
	u64 cr6, u64 schid);		u64 cr6, u64 schid);

	@@ -150,8 +144,8 @@ int kvm_s390_handle_eb(struct kvm_vcpu *vcpu);
	int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu);		int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu);

	/* implemented in kvm-s390.c */		/* implemented in kvm-s390.c */
	int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu,		int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr);
	unsigned long addr);		int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr);
	void s390_vcpu_block(struct kvm_vcpu *vcpu);		void s390_vcpu_block(struct kvm_vcpu *vcpu);
	void s390_vcpu_unblock(struct kvm_vcpu *vcpu);		void s390_vcpu_unblock(struct kvm_vcpu *vcpu);
	void exit_sie(struct kvm_vcpu *vcpu);		void exit_sie(struct kvm_vcpu *vcpu);

arch/s390/kvm/priv.c

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -197,7 +197,7 @@ static int handle_tpi(struct kvm_vcpu *vcpu)
	if (addr & 3)		if (addr & 3)
	return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	cc = 0;		cc = 0;
	inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->run->s.regs.crs[6], 0);		inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->arch.sie_block->gcr[6], 0);
	if (!inti)		if (!inti)
	goto no_interrupt;		goto no_interrupt;
	cc = 1;		cc = 1;
	@@ -638,7 +638,6 @@ static int handle_pfmf(struct kvm_vcpu *vcpu)

	static const intercept_handler_t b9_handlers[256] = {		static const intercept_handler_t b9_handlers[256] = {
	[0x8d] = handle_epsw,		[0x8d] = handle_epsw,
	[0x9c] = handle_io_inst,
	[0xaf] = handle_pfmf,		[0xaf] = handle_pfmf,
	};		};

	@@ -731,7 +730,6 @@ static int handle_lctlg(struct kvm_vcpu *vcpu)

	static const intercept_handler_t eb_handlers[256] = {		static const intercept_handler_t eb_handlers[256] = {
	[0x2f] = handle_lctlg,		[0x2f] = handle_lctlg,
	[0x8a] = handle_io_inst,
	};		};

	int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)		int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)

arch/s390/kvm/sigp.c

+49 −7

Original line number	Original line	Diff line number	Diff line
	@@ -130,6 +130,7 @@ unlock:
	static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)		static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
	{		{
	struct kvm_s390_interrupt_info *inti;		struct kvm_s390_interrupt_info *inti;
			int rc = SIGP_CC_ORDER_CODE_ACCEPTED;

	inti = kzalloc(sizeof(*inti), GFP_ATOMIC);		inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
	if (!inti)		if (!inti)
	@@ -139,6 +140,8 @@ static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
	spin_lock_bh(&li->lock);		spin_lock_bh(&li->lock);
	if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {		if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
	kfree(inti);		kfree(inti);
			if ((action & ACTION_STORE_ON_STOP) != 0)
			rc = -ESHUTDOWN;
	goto out;		goto out;
	}		}
	list_add_tail(&inti->list, &li->list);		list_add_tail(&inti->list, &li->list);
	@@ -150,7 +153,7 @@ static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
	out:		out:
	spin_unlock_bh(&li->lock);		spin_unlock_bh(&li->lock);

	return SIGP_CC_ORDER_CODE_ACCEPTED;		return rc;
	}		}

	static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)		static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
	@@ -174,13 +177,17 @@ static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
	unlock:		unlock:
	spin_unlock(&fi->lock);		spin_unlock(&fi->lock);
	VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);		VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
	return rc;
			if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
			/* If the CPU has already been stopped, we still have
			* to save the status when doing stop-and-store. This
			* has to be done after unlocking all spinlocks. */
			struct kvm_vcpu *dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
			rc = kvm_s390_store_status_unloaded(dst_vcpu,
			KVM_S390_STORE_STATUS_NOADDR);
	}		}

	int kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action)		return rc;
	{
	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	return __inject_sigp_stop(li, action);
	}		}

	static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)		static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
	@@ -262,6 +269,37 @@ out_fi:
	return rc;		return rc;
	}		}

			static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
			u32 addr, u64 *reg)
			{
			struct kvm_vcpu *dst_vcpu = NULL;
			int flags;
			int rc;

			if (cpu_id < KVM_MAX_VCPUS)
			dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
			if (!dst_vcpu)
			return SIGP_CC_NOT_OPERATIONAL;

			spin_lock_bh(&dst_vcpu->arch.local_int.lock);
			flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
			spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
			if (!(flags & CPUSTAT_STOPPED)) {
			*reg &= 0xffffffff00000000UL;
			*reg \|= SIGP_STATUS_INCORRECT_STATE;
			return SIGP_CC_STATUS_STORED;
			}

			addr &= 0x7ffffe00;
			rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
			if (rc == -EFAULT) {
			*reg &= 0xffffffff00000000UL;
			*reg \|= SIGP_STATUS_INVALID_PARAMETER;
			rc = SIGP_CC_STATUS_STORED;
			}
			return rc;
			}

	static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,		static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
	u64 *reg)		u64 *reg)
	{		{
	@@ -366,6 +404,10 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
	rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP \|		rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP \|
	ACTION_STOP_ON_STOP);		ACTION_STOP_ON_STOP);
	break;		break;
			case SIGP_STORE_STATUS_AT_ADDRESS:
			rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
			&vcpu->run->s.regs.gprs[r1]);
			break;
	case SIGP_SET_ARCHITECTURE:		case SIGP_SET_ARCHITECTURE:
	vcpu->stat.instruction_sigp_arch++;		vcpu->stat.instruction_sigp_arch++;
	rc = __sigp_set_arch(vcpu, parameter);		rc = __sigp_set_arch(vcpu, parameter);

Admin message