[PATCH 1/5] kvm-s390: infrastructure to kick vcpus out of guest state - v3

ehrhardt
2009-05-28T15:43:11Z

- ensure allocations (might_sleep) are out of atomic context

*updates in v2*
instead of a "kick to level" behaviour the patch now implements a kick to the
lowest level. The check there bails out to upper levels if not all outstanding
vcpu->requests could be handled internally (it could still support an explicit
kick to level if ever needed).

To ensure vcpu's come out of guest context in certain cases this patch adds a
s390 specific way to kick them out of guest context. Currently it kicks them
out to rerun the vcpu_run path in the s390 code, but the mechanism itself is
expandable and with a new flag we could also add e.g. kicks to userspace etc.

Signed-off-by: Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
---

[diffstat]
include/asm/kvm_host.h | 5 ++--
kvm/intercept.c | 14 +++++++++--
kvm/kvm-s390.c | 6 ++++
kvm/kvm-s390.h | 17 ++++++++++++++
kvm/sigp.c | 59 ++++++++++++++++++++++++++++++++++---------------
5 files changed, 79 insertions(+), 22 deletions(-)

[diff]
Index: kvm/arch/s390/kvm/intercept.c
===================================================================
--- kvm.orig/arch/s390/kvm/intercept.c
+++ kvm/arch/s390/kvm/intercept.c
@@ -128,7 +128,7 @@ static int handle_noop(struct kvm_vcpu *

static int handle_stop(struct kvm_vcpu *vcpu)
{
- int rc;
+ int rc = 0;

vcpu->stat.exit_stop_request++;
atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
@@ -141,12 +141,20 @@ static int handle_stop(struct kvm_vcpu *
rc = -ENOTSUPP;
}

+ if (vcpu->arch.local_int.action_bits & ACTION_VCPUREQUEST_ON_STOP) {
+ vcpu->arch.local_int.action_bits &= ~ACTION_VCPUREQUEST_ON_STOP;
+ if (kvm_s390_handle_vcpu_requests(vcpu, VCPUREQUESTLVL_SIGP)) {
+ rc = SIE_INTERCEPT_CHECKREQUESTS;
+ vcpu->run->exit_reason = KVM_EXIT_INTR;
+ }
+ }
+
if (vcpu->arch.local_int.action_bits & ACTION_STOP_ON_STOP) {
vcpu->arch.local_int.action_bits &= ~ACTION_STOP_ON_STOP;
VCPU_EVENT(vcpu, 3, "%s", "cpu stopped");
rc = -ENOTSUPP;
- } else
- rc = 0;
+ }
+
spin_unlock_bh(&vcpu->arch.local_int.lock);
return rc;
}
Index: kvm/arch/s390/kvm/kvm-s390.c
===================================================================
--- kvm.orig/arch/s390/kvm/kvm-s390.c
+++ kvm/arch/s390/kvm/kvm-s390.c
@@ -487,6 +487,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_v

vcpu_load(vcpu);

+rerun_vcpu:
+ kvm_s390_handle_vcpu_requests(vcpu, VCPUREQUESTLVL_VCPURUN);
+
/* verify, that memory has been registered */
if (!vcpu->kvm->arch.guest_memsize) {
vcpu_put(vcpu);
@@ -519,6 +522,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_v
rc = kvm_handle_sie_intercept(vcpu);
} while (!signal_pending(current) && !rc);

+ if (rc == SIE_INTERCEPT_CHECKREQUESTS)
+ goto rerun_vcpu;
+
if (signal_pending(current) && !rc)
rc = -EINTR;

Index: kvm/arch/s390/kvm/kvm-s390.h
===================================================================
--- kvm.orig/arch/s390/kvm/kvm-s390.h
+++ kvm/arch/s390/kvm/kvm-s390.h
@@ -20,6 +20,8 @@

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

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

#define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\
@@ -50,6 +52,21 @@ int kvm_s390_inject_vm(struct kvm *kvm,
int kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
struct kvm_s390_interrupt *s390int);
int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code);
+int kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action);
+
+/* interception levels from which handle vcpu requests can be called */
+#define VCPUREQUESTLVL_SIGP 1
+#define VCPUREQUESTLVL_VCPURUN 2
+static inline unsigned long kvm_s390_handle_vcpu_requests(struct kvm_vcpu *vcpu,
+ int level)
+{
+ BUG_ON(!level);
+
+ if (!vcpu->requests)
+ return 0;
+
+ return vcpu->requests;
+}

/* implemented in priv.c */
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu);
Index: kvm/arch/s390/include/asm/kvm_host.h
===================================================================
--- kvm.orig/arch/s390/include/asm/kvm_host.h
+++ kvm/arch/s390/include/asm/kvm_host.h
@@ -180,8 +180,9 @@ struct kvm_s390_interrupt_info {
};

/* for local_interrupt.action_flags */
-#define ACTION_STORE_ON_STOP 1
-#define ACTION_STOP_ON_STOP 2
+#define ACTION_STORE_ON_STOP (1<<0)
+#define ACTION_STOP_ON_STOP (1<<1)
+#define ACTION_VCPUREQUEST_ON_STOP (1<<2)

struct kvm_s390_local_interrupt {
spinlock_t lock;
Index: kvm/arch/s390/kvm/sigp.c
===================================================================
--- kvm.orig/arch/s390/kvm/sigp.c
+++ kvm/arch/s390/kvm/sigp.c
@@ -1,7 +1,7 @@
/*
* sigp.c - handlinge interprocessor communication
*
- * Copyright IBM Corp. 2008
+ * Copyright IBM Corp. 2008,2009
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License (version 2 only)
@@ -9,6 +9,7 @@
*
* Author(s): Carsten Otte <cotte@de.ibm.com>
* Christian Borntraeger <borntraeger@de.ibm.com>
+ * Christian Ehrhardt <ehrhardt@de.ibm.com>
*/

#include <linux/kvm.h>
@@ -107,7 +108,22 @@ unlock:
return rc;
}

-static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int store)
+static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action,
+ struct kvm_s390_interrupt_info *inti)
+{
+ spin_lock_bh(&li->lock);
+ list_add_tail(&inti->list, &li->list);
+ atomic_set(&li->active, 1);
+ atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
+ li->action_bits |= action;
+ if (waitqueue_active(&li->wq))
+ wake_up_interruptible(&li->wq);
+ spin_unlock_bh(&li->lock);
+
+ return 0; /* order accepted */
+}
+
+static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
{
struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
struct kvm_s390_local_interrupt *li;
@@ -120,33 +136,42 @@ static int __sigp_stop(struct kvm_vcpu *
inti = kzalloc(sizeof(*inti), GFP_KERNEL);
if (!inti)
return -ENOMEM;
-
inti->type = KVM_S390_SIGP_STOP;

spin_lock(&fi->lock);
li = fi->local_int[cpu_addr];
if (li == NULL) {
rc = 3; /* not operational */
- kfree(inti);
goto unlock;
}
- spin_lock_bh(&li->lock);
- list_add_tail(&inti->list, &li->list);
- atomic_set(&li->active, 1);
- atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
- if (store)
- li->action_bits |= ACTION_STORE_ON_STOP;
- li->action_bits |= ACTION_STOP_ON_STOP;
- if (waitqueue_active(&li->wq))
- wake_up_interruptible(&li->wq);
- spin_unlock_bh(&li->lock);
- rc = 0; /* order accepted */
+
+ rc = __inject_sigp_stop(li, action, inti);
+
unlock:
spin_unlock(&fi->lock);
+ if (rc)
+ kfree(inti);
VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
return rc;
}

+int kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action)
+{
+ struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
+ struct kvm_s390_interrupt_info *inti;
+ int rc;
+
+ inti = kzalloc(sizeof(*inti), GFP_KERNEL);
+ if (!inti)
+ return -ENOMEM;
+ inti->type = KVM_S390_SIGP_STOP;
+
+ rc = __inject_sigp_stop(li, action, inti);
+ if (rc)
+ kfree(inti);
+ return rc;
+}
+
static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
{
int rc;
@@ -261,11 +286,11 @@ int kvm_s390_handle_sigp(struct kvm_vcpu
break;
case SIGP_STOP:
vcpu->stat.instruction_sigp_stop++;
- rc = __sigp_stop(vcpu, cpu_addr, 0);
+ rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
break;
case SIGP_STOP_STORE_STATUS:
vcpu->stat.instruction_sigp_stop++;
- rc = __sigp_stop(vcpu, cpu_addr, 1);
+ rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP);
break;
case SIGP_SET_ARCH:
vcpu->stat.instruction_sigp_arch++;