kvm-s390: revised version of kvm-s390 guest memory handling - v2
cover kvm-s390: revised version of kvm-s390 guest memory handling - v2
From: Christian Ehrhardt <[email protected]>
*update in v2*
added optimization to patch 3/3 to skip (addtional) kickout of vcpu's that had the request already set.
This patch series results from our discussions about handling memslots and vcpu mmu reloads. It streamlines kvm-s390 a bit by using slots_lock, vcpu-request (KVM_REQ_MMU_RELOAD) and a kick mechanism to ensure vcpus come out of guest context to catch the update.
I tested the reworked code a while with multiple smp guests and some extra code that periodically injects kicks and/or mmu reload requests, but I'm happy about every additional review feedback.
Patches included:
Subject: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Subject: [PATCH 2/3] kvm-s390: fix signal handling
Subject: [PATCH 3/3] kvm-s390: streamline memslot handling
Overall-Diffstat:
arch/s390/include/asm/kvm_host.h | 4 -- arch/s390/kvm/intercept.c | 6 +-- arch/s390/kvm/kvm-s390.c | 54 +++++++++++---------------------- arch/s390/kvm/kvm-s390.h | 29 +++++++++++++++++- arch/s390/kvm/sigp.c | 4 +- kvm/arch/s390/include/asm/kvm_host.h | 5 +-- kvm/arch/s390/kvm/gaccess.h | 23 +++++++------- kvm/arch/s390/kvm/intercept.c | 12 +++++-- kvm/arch/s390/kvm/kvm-s390.c | 5 +++ kvm/arch/s390/kvm/kvm-s390.h | 3 + kvm/arch/s390/kvm/sigp.c | 56 +++++++++++++++++++++-------------- 11 files changed, 119 insertions(+), 82 deletions(-)
PATCH 1/3 kvm-s390: infrastructure to kick vcpus out of guest state
From: Christian Ehrhardt <[email protected]>
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.
---
[diffstat]
include/asm/kvm_host.h | 5 ++-- kvm/intercept.c | 12 ++++++++--- kvm/kvm-s390.c | 5 ++++ kvm/kvm-s390.h | 3 ++ kvm/sigp.c | 53 +++++++++++++++++++++++++++++-------------------- 5 files changed, 52 insertions(+), 26 deletions(-)
[diff]
arch/s390/kvm/intercept.c +9 -3
@@ -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,18 @@ static int handle_stop(struct kvm_vcpu * rc = -ENOTSUPP ; } +if (vcpu->arch.local_int.action_bits &ACTION_RELOADVCPU_ON_STOP ) { + vcpu->arch.local_int.action_bits &= ~ACTION_RELOADVCPU_ON_STOP ; + rc =SIE_INTERCEPT_RERUNVCPU ; + 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; }
arch/s390/kvm/kvm-s390.c +5 -0
@@ -487,6 +487,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vvcpu_load (vcpu); +rerun_vcpu:/* verify, that memory has been registered */ if (!vcpu->kvm->arch.guest_memsize) {vcpu_put (vcpu);
@@ -506,6 +507,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_v vcpu->arch.sie_block->gpsw.addr = kvm_run->s390_sieic.addr;break ;case KVM_EXIT_UNKNOWN : +case KVM_EXIT_INTR :case KVM_EXIT_S390_RESET :break ;default :
@@ -519,6 +521,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_RERUNVCPU ) + goto rerun_vcpu; +if (signal_pending (current) && !rc) rc = -EINTR ;
arch/s390/kvm/kvm-s390.h +3 -0
@@ -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_RERUNVCPU (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,7 @@ 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);/* implemented in priv.c */ int kvm_s390_handle_b2 (struct kvm_vcpu *vcpu);
arch/s390/include/asm/kvm_host.h +3 -2
@@ -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_RELOADVCPU_ON_STOP (1<<2)struct kvm_s390_local_interrupt {spinlock_t lock;
arch/s390/kvm/sigp.c +34 -22
104 lines not on this page · raw message
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 8 lines · On Mon, May 25, 2009 at 01:40:49PM +0200, [email protected] wrote:
From: Christian Ehrhardt <[email protected]>
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_runpath 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 <[email protected]>
"For now I added the optimization to skip kicking vcpus out of guest that had the request bit already set to the s390 specific loop (sent as v2 in a few minutes).
We might one day consider standardizing some generic kickout levels e.g. kick to "inner loop", "arch vcpu run", "generic vcpu run", "userspace", ... whatever levels fit *all* our use cases. And then let that kicks be implemented in an kvm_arch_* backend as it might be very different how they behave on different architectures."
That would be ideal, yes. Two things make_all_requests handles:
1) It disables preemption with get_cpu(), so it can reliably check for cpu id. Somehow you don't need that for s390 when kicking multiple vcpus?
2) It uses smp_call_function_many(wait=1), which guarantees that by the time make_all_requests returns no vcpus will be using stale data (the remote vcpus will have executed ack_flush).
If smp_call_function_many is hidden behind kvm_arch_kick_vcpus, can you make use of make_all_requests for S390 (without the smp_call_function performance impact you mentioned) ?
For x86 we can further optimize make_all_requests by checking REQ_KICK, and kvm_arch_kick_vcpus would be a good place for that.
And the kickout levels idea you mentioned can come later, as an optimization?
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 22 lines · Marcelo Tosatti
Quoted 9 lines · On Mon, May 25, 2009 at 01:40:49PM +0200, [email protected] wrote:
From: Christian Ehrhardt <[email protected]>
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_runpath 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 <[email protected]>"For now I added the optimization to skip kicking vcpus out of guest that had the request bit already set to the s390 specific loop (sent as v2 in a few minutes).
We might one day consider standardizing some generic kickout levels e.g. kick to "inner loop", "arch vcpu run", "generic vcpu run", "userspace", ... whatever levels fit *all* our use cases. And then let that kicks be implemented in an kvm_arch_* backend as it might be very different how they behave on different architectures."
Quoted 6 lines
That would be ideal, yes. Two things
make_all_requestshandles:1) It disables preemption with
get_cpu(), so it can reliably check for cpu id. Somehow you don't need that for s390 when kicking multiple vcpus?
I don't even need the cpuid as make_all_requests does, I just insert a special bit in the vcpu arch part and the vcpu will "come out to me (host)".
Fortunateley the kick is rare and fast so I can just insert it unconditionally (it's even ok to insert it if the vcpu is not in guest state). That prevents us from needing vcpu lock or detailed checks which would end up where we started (no guarantee that vcpu's come out of guest context while trying to aquire all vcpu locks)
Quoted 4 lines
2) It uses
smp_call_function_many(wait=1), which guarantees that by the timemake_all_requestsreturns no vcpus will be using stale data (the remote vcpus will have executedack_flush).
yes this is really a part my s390 implementation doesn't fulfill yet. Currently on return vcpus might still use the old memslot information.
As mentioned before letting all interrupts come "too far" out of the hot loop would be a performance issue, therefore I think I will need some request&confirm mechanism. I'm not sure yet but maybe it could be as easy as this pseudo code example:
# in make_all_requests # remember we have slots_lock write here and the reentry that updates the vcpu specific data aquires slots_lock for read. loop vcpus set_bit in vcpu requests kick vcpu #arch function endloop
loop vcpus
until the requested bit is disappeared #as the reentry path usestest_and_clear it will disappear
endloop
That would be a implicit synchronization and should work, as I wrote before setting memslots while the guest is running is rare if ever existant for s390. On x86 smp_call_many could then work without the wait flag being set. But I assume that this synchronization approach is slower as it serializes all vcpus on reentry (they wait for the slots_lock to get dropped), therefore I wanted to ask how often setting memslots on runtime will occur on x86 ? Would this approach be acceptable ?
If it is too adventurous for now I can implement it that way in the s390 code and we split the long term discussion (synchronization + generic kickout levels + who knows what comes up).
Quoted 3 lines
If
smp_call_function_manyis hidden behindkvm_arch_kick_vcpus, can you
make use ofmake_all_requestsfor S390 (without thesmp_call_functionperformance impact you mentioned) ?
In combination with the request&confirm mechanism desribed above it should work if smp_call function and all the cpuid gathering which belongs to it is hidden behind kvm_arch_kick_vcpus.
Quoted 5 lines
For x86 we can further optimize
make_all_requestsby checkingREQ_KICK, andkvm_arch_kick_vcpuswould be a good place for that.And the kickout levels idea you mentioned can come later, as an optimization?
yes I agree splitting that to a later optimization is a good idea.
Quoted 5 lines
--
To unsubscribe from this list: send the line "unsubscribe kvm" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Signature · 2 lines
Grüsse / regards, Christian Ehrhardt IBM Linux Technology Center, Open Virtualization
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 29 lines · Christian Ehrhardt
Quoted 22 lines · Marcelo Tosatti
Quoted 9 lines · On Mon, May 25, 2009 at 01:40:49PM +0200, [email protected] wrote:
From: Christian Ehrhardt <[email protected]>
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_runpath 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 <[email protected]>"For now I added the optimization to skip kicking vcpus out of guest that had the request bit already set to the s390 specific loop (sent as v2 in a few minutes).
We might one day consider standardizing some generic kickout levels e.g. kick to "inner loop", "arch vcpu run", "generic vcpu run", "userspace", ... whatever levels fit *all* our use cases. And then let that kicks be implemented in an kvm_arch_* backend as it might be very different how they behave on different architectures."
Quoted 6 lines
That would be ideal, yes. Two things
make_all_requestshandles:1) It disables preemption with
get_cpu(), so it can reliably check for cpu id. Somehow you don't need that for s390 when kicking multiple vcpus?
Quoted 8 lines
I don't even need the cpuid as
make_all_requestsdoes, I just insert a special bit in the vcpu arch part and the vcpu will "come out to me (host)".
Fortunateley the kick is rare and fast so I can just insert it unconditionally (it's even ok to insert it if the vcpu is not in guest state). That prevents us from needing vcpu lock or detailed checks which would end up where we started (no guarantee that vcpu's come out of guest context while trying to aquire all vcpu locks)
Let me see if I get this right: you kick the vcpus out of guest mode by using a special bit in the vcpu arch part. OK.
What I don't understand is this:
"would end up where we started (no guarantee that vcpu's come out of guest context while trying to aquire all vcpu locks)"
So you _need_ a mechanism to kick all vcpus out of guest mode?
Quoted 24 lines
Quoted 4 lines
2) It uses
smp_call_function_many(wait=1), which guarantees that by the timemake_all_requestsreturns no vcpus will be using stale data (the remote vcpus will have executedack_flush).yes this is really a part my s390 implementation doesn't fulfill yet. Currently on return vcpus might still use the old memslot information. As mentioned before letting all interrupts come "too far" out of the hot loop would be a performance issue, therefore I think I will need some request&confirm mechanism. I'm not sure yet but maybe it could be as easy as this pseudo code example:
# in make_all_requests # remember we have slots_lock write here and the reentry that updates the vcpu specific data aquires slots_lock for read. loop vcpus set_bit in vcpu requests kick vcpu #arch function endlooploop vcpus
until the requested bit is disappeared #as the reentry path usestest_and_clearit will disappear
endloop
Quoted 4 lines
That would be a implicit synchronization and should work, as I wrote before setting memslots while the guest is running is rare if ever existant for s390. On x86
smp_call_manycould then work without the wait flag being set.
I see, yes.
Quoted 4 lines
But I assume that this synchronization approach is slower as it serializes all vcpus on reentry (they wait for the
slots_lockto get dropped), therefore I wanted to ask how often setting memslots on runtime will occur on x86 ? Would this approach be acceptable ?
For x86 we need slots_lock for two things:
1) to protect the memslot structures from changing (very rare), ie:kvm_set_memory.
2) to protect updates to the dirty bitmap (operations on behalf of guest) which take slots_lock for read versus updates to that dirty bitmap (an ioctl that retrieves what pages have been dirtied in the memslots, and clears the dirtyness info).
All you need for S390 is 1), AFAICS.
For 1), we can drop the slots_lock usage, but instead create an explicit synchronization point, where all vcpus are forced to (say kvm_vcpu_block) "paused" state. qemu-kvm has such notion.
Same language?
Quoted 28 lines
If it is too adventurous for now I can implement it that way in the s390 code and we split the long term discussion (synchronization + generic kickout levels + who knows what comes up).
Quoted 4 lines
If
smp_call_function_manyis hidden behindkvm_arch_kick_vcpus, can you make use ofmake_all_requestsfor S390 (without thesmp_call_functionperformance impact you mentioned) ?In combination with the request&confirm mechanism desribed above it should work if
smp_callfunction and all the cpuid gathering which belongs to it is hidden behindkvm_arch_kick_vcpus.Quoted 5 lines
For x86 we can further optimize
make_all_requestsby checkingREQ_KICK, andkvm_arch_kick_vcpuswould be a good place for that.And the kickout levels idea you mentioned can come later, as an optimization?
yes I agree splitting that to a later optimization is a good idea.
Quoted 5 lines
--
To unsubscribe from this list: send the line "unsubscribe kvm" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.htmlSignature · 2 lines
Grüsse / regards, Christian Ehrhardt IBM Linux Technology Center, Open Virtualization
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 38 lines · Marcelo Tosatti
Quoted 27 lines · Christian Ehrhardt
Quoted 25 lines · Marcelo Tosatti
Quoted 10 lines · On Mon, May 25, 2009 at 01:40:49PM +0200, [email protected] wrote:
From: Christian Ehrhardt <[email protected]>
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_runpath 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 <[email protected]>"For now I added the optimization to skip kicking vcpus out of guest that had the request bit already set to the s390 specific loop (sent as v2 in a few minutes).
We might one day consider standardizing some generic kickout levels e.g. kick to "inner loop", "arch vcpu run", "generic vcpu run", "userspace", ... whatever levels fit *all* our use cases. And then let that kicks be implemented in an kvm_arch_* backend as it might be very different how they behave on different architectures."
That would be ideal, yes. Two things
make_all_requestshandles:Quoted 8 lines
Quoted 5 lines
1) It disables preemption with
get_cpu(), so it can reliably check for cpu id. Somehow you don't need that for s390 when kicking multiple vcpus?I don't even need the cpuid as
make_all_requestsdoes, I just insert a special bit in the vcpu arch part and the vcpu will "come out to me (host)".
Fortunateley the kick is rare and fast so I can just insert it unconditionally (it's even ok to insert it if the vcpu is not in guest state). That prevents us from needing vcpu lock or detailed checks which would end up where we started (no guarantee that vcpu's come out of guest context while trying to aquire all vcpu locks)
Quoted 6 lines
Let me see if I get this right: you kick the vcpus out of guest mode by using a special bit in the vcpu arch part. OK.
What I don't understand is this: "would end up where we started (no guarantee that vcpu's come out of guest context while trying to aquire all vcpu locks)"
initially the mechanism looped over vcpu's and just aquired the vcpu lock and then updated the vcpu.arch infor directly.
Avi mentioned that we have no guarantee if/when the vcpu will come out of guest context to free a lock currently held and suggested the mechanism x86 uses via setting vcpu->request and kicking the vcpu. Thats the eason behind "end up where we (the discussion) started", if we would need the vcpu lock again we would be at the beginnign of the discussion.
Quoted 2 lines
So you _need_ a mechanism to kick all vcpus out of guest mode?
I have a mechanism to kick a vcpu, and I use it. Due to the fact that smp_call_* don't work as kick for us the kick is an arch specific function. I hop ethat clarified this part :-)
Quoted 34 lines
Quoted 15 lines
Quoted 5 lines
2) It uses
smp_call_function_many(wait=1), which guarantees that by the timemake_all_requestsreturns no vcpus will be using stale data (the remote vcpus will have executedack_flush).yes this is really a part my s390 implementation doesn't fulfill yet. Currently on return vcpus might still use the old memslot information.
As mentioned before letting all interrupts come "too far" out of the hot loop would be a performance issue, therefore I think I will need some request&confirm mechanism. I'm not sure yet but maybe it could be as easy as this pseudo code example:# in make_all_requests # remember we have slots_lock write here and the reentry that updates the vcpu specific data aquires slots_lock for read. loop vcpus set_bit in vcpu requests kick vcpu #arch function endloopQuoted 7 lines
loop vcpus
until the requested bit is disappeared #as the reentry path usestest_and_clearit will disappear
endloopThat would be a implicit synchronization and should work, as I wrote before setting memslots while the guest is running is rare if ever existant for s390. On x86
smp_call_manycould then work without the wait flag being set.I see, yes.
Quoted 2 lines
But I assume that this synchronization approach is slower as it serializes all vcpus on reentry (they wait for the
slots_lockto get dropped), therefore I wanted to ask how often setting memslots on runtime will occur on x86 ? Would this approach be acceptable ?For x86 we need
slots_lockfor two things:1) to protect the memslot structures from changing (very rare), ie:
kvm_set_memory.
Quoted 7 lines
2) to protect updates to the dirty bitmap (operations on behalf of guest) which take
slots_lockfor read versus updates to that dirty bitmap (an ioctl that retrieves what pages have been dirtied in the memslots, and clears the dirtyness info).All you need for S390 is 1), AFAICS.
correct
Quoted 6 lines
For 1), we can drop the
slots_lockusage, but instead create an explicit synchronization point, where all vcpus are forced to (saykvm_vcpu_block) "paused" state. qemu-kvm has such notion.Same language?
Yes, I think i got your point :-)
But I think by keeping slots_lock we already got our synchronization point and don't need an explicit one adding extra code and maybe locks.
As I mentioned above it should synchronize already implicit. When I looked at it once more yesterday I realized that kvm_set_memory is not performance critical anyway (i.e. does not have to be the fastest ioctl on earth) so we could be one step smarter and instead of serializing all vcpu's among each other we could set_memory just let do it one by one.
In case I lost you again due to my obviously confusing mainframe language this week you might want to my next patch submission where I implement that in the s390 arch code as an example. I'll put you on cc and in that new code we might find an implicit language synchronization for us :-)
[...]
Signature · 2 lines
Grüsse / regards, Christian Ehrhardt IBM Linux Technology Center, Open Virtualization
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 5 lines · Christian Ehrhardt
Quoted 2 lines
So you _need_ a mechanism to kick all vcpus out of guest mode?
I have a mechanism to kick a vcpu, and I use it. Due to the fact that smp_call_* don't work as kick for us the kick is an arch specific function. I hop ethat clarified this part :-)
You could still use make_all_vcpus_request(), just change smp_call_function_many() to your own kicker.
Signature · 2 lines
I have a truly marvellous patch that fixes the bug which this signature is too narrow to contain.
Re: [PATCH 1/3] kvm-s390: infrastructure to kick vcpus out of guest state
Quoted 9 lines · Avi Kivity
Quoted 5 lines · Christian Ehrhardt
Quoted 2 lines
So you _need_ a mechanism to kick all vcpus out of guest mode?
I have a mechanism to kick a vcpu, and I use it. Due to the fact that smp_call_* don't work as kick for us the kick is an arch specific function. I hop ethat clarified this part :-)
You could still use
make_all_vcpus_request(), just changesmp_call_function_many()to your own kicker.
Yes and I like this idea for further unification, but I don't want it mixed too much into the patches in discussion atm.
Because on one hand I have some problems giving my arch specific kick a behaviour like "return when the guest WAS kicked" and on the other hand I would e.g. also need to streamline the check in make_all_vcpus_request which cpu is running etc because vcpu->cpu stays -1 all the time on s390 (never used).
Therefore I would unify things step by step and this way allow single task to went off my task pile here :-)
Signature · 2 lines
Grüsse / regards, Christian Ehrhardt IBM Linux Technology Center, Open Virtualization
PATCH 2/3 kvm-s390: fix signal handling
In reply to [email protected]From: Christian Ehrhardt <[email protected]>
If signal pending is true we exit without updating kvm_run, userspace currently just does nothing and jumps to kvm_run again. Since we did not set an exit_reason we might end up with a random one (whatever was the last exit). Therefore it was possible to e.g. jump to the psw position the last real interruption set.
Setting the INTR exit reason ensures that no old psw data is swapped in on reentry.
---
[diffstat]
kvm-s390.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
[diff]
arch/s390/kvm/kvm-s390.c +3 -1
@@ -524,8 +524,10 @@ rerun_vcpu:if (rc ==SIE_INTERCEPT_RERUNVCPU ) goto rerun_vcpu; -if (signal_pending (current) && !rc) +if (signal_pending (current) && !rc) { + kvm_run->exit_reason =KVM_EXIT_INTR ; rc = -EINTR ; + }if (rc == -ENOTSUPP ) {/* intercept cannot be handled in-kernel, prepare kvm-run */
PATCH 1/1 kvm-s390: streamline memslot handling - v2
In reply to [email protected]From: Christian Ehrhardt <[email protected]>
*update in v2*
added optimization to skip (addtional) kickout of vcpu's that had the request already set.
This patch relocates the variables kvm-s390 uses to track guest mem addr/size. As discussed dropping the variables at struct kvm_arch level allows to use the common vcpu->request based mechanism to reload guest memory if e.g. changes via set_memory_region.
The kick mechanism introduced in this series is used to ensure running vcpus leave guest state to catch the update.
---
[diffstat]
include/asm/kvm_host.h | 4 --- kvm/gaccess.h | 23 +++++++++++----------- kvm/intercept.c | 6 ++--- kvm/kvm-s390.c | 50 +++++++++++++++---------------------------------- kvm/kvm-s390.h | 29 +++++++++++++++++++++++++++- kvm/sigp.c | 4 +-- 6 files changed, 62 insertions(+), 54 deletions(-)
[diff]
arch/s390/kvm/gaccess.h +12 -11
@@ -1,7 +1,7 @@/* * gaccess.h - access guest memory * -* 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)
@@ -16,13 +16,14 @@#include <linux/compiler.h> #include <linux/kvm_host.h> #include <asm/uaccess.h> +#include "kvm-s390.h" static inline void __user *__guestaddr_to_user (struct kvm_vcpu *vcpu,unsigned long guestaddr) {unsigned long prefix = vcpu->arch.sie_block->prefix; -unsigned long origin = vcpu->kvm->arch.guest_origin; -unsigned long memsize = vcpu->kvm->arch.guest_memsize; +unsigned long origin = vcpu->arch.sie_block->gmsor; +unsigned long memsize =kvm_s390_vcpu_get_memsize (vcpu);if (guestaddr <2 *PAGE_SIZE ) guestaddr += prefix;
@@ -158,8 +159,8 @@ static inline int copy_to_guest(struct k const void *from, unsigned long n) { unsigned long prefix = vcpu->arch.sie_block->prefix; -unsigned long origin = vcpu->kvm->arch.guest_origin; -unsigned long memsize = vcpu->kvm->arch.guest_memsize; +unsigned long origin = vcpu->arch.sie_block->gmsor; +unsigned long memsize =kvm_s390_vcpu_get_memsize (vcpu);if ((guestdest <2 *PAGE_SIZE ) && (guestdest + n >2 *PAGE_SIZE )) goto slowpath;
@@ -209,8 +210,8 @@ static inline int copy_from_guest(struct unsigned long guestsrc, unsigned long n) {unsigned long prefix = vcpu->arch.sie_block->prefix; -unsigned long origin = vcpu->kvm->arch.guest_origin; -unsigned long memsize = vcpu->kvm->arch.guest_memsize; +unsigned long origin = vcpu->arch.sie_block->gmsor; +unsigned long memsize =kvm_s390_vcpu_get_memsize (vcpu);if ((guestsrc <2 *PAGE_SIZE ) && (guestsrc + n >2 *PAGE_SIZE )) goto slowpath;
@@ -244,8 +245,8 @@ static inline int copy_to_guest_absoluteunsigned long guestdest, const void *from, unsigned long n) { - unsigned long origin = vcpu->kvm->arch.guest_origin; -unsigned long memsize = vcpu->kvm->arch.guest_memsize; + unsigned long origin = vcpu->arch.sie_block->gmsor; +unsigned long memsize =kvm_s390_vcpu_get_memsize (vcpu);if (guestdest + n > memsize)return -EFAULT ;
@@ -262,8 +263,8 @@ static inline int copy_from_guest_absolu unsigned long guestsrc, unsigned long n) { -unsigned long origin = vcpu->kvm->arch.guest_origin; -unsigned long memsize = vcpu->kvm->arch.guest_memsize; +unsigned long origin = vcpu->arch.sie_block->gmsor; +unsigned long memsize =kvm_s390_vcpu_get_memsize (vcpu);if (guestsrc + n > memsize)return -EFAULT ;
arch/s390/kvm/intercept.c +3 -3
@@ -1,7 +1,7 @@/* * intercept.c - in-kernel handling for sie intercepts * -* 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)
@@ -164,9 +164,9 @@ static int handle_validity(struct kvm_vc vcpu->stat.exit_validity++;if ((viwhy ==0x37 ) && (vcpu->arch.sie_block->prefix - <= vcpu->kvm->arch.guest_memsize -2 *PAGE_SIZE )){ + <=kvm_s390_vcpu_get_memsize (vcpu) -2 *PAGE_SIZE )) { rc =fault_in_pages_writeable ((char __user *) - vcpu->kvm->arch.guest_origin + + vcpu->arch.sie_block->gmsor + vcpu->arch.sie_block->prefix,2 *PAGE_SIZE );if (rc)
arch/s390/kvm/kvm-s390.c +16 -34
97 lines not on this page · raw message
arch/s390/kvm/kvm-s390.h +28 -1
@@ -1,7 +1,7 @@/* * kvm_s390.h - definition for kvm on s390 * -* 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 <[email protected]> * Christian Borntraeger <[email protected]> +* Christian Ehrhardt <[email protected]> */ #ifndef ARCH_S390_KVM_S390_H
@@ -18,6 +19,9 @@#include <linux/kvm.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);/* negativ values are error codes, positive values for internal conditions */
@@ -54,6 +58,29 @@ int kvm_s390_inject_vcpu(struct kvm_vcpuint kvm_s390_inject_program_int (struct kvm_vcpu *vcpu,u16 code);int kvm_s390_inject_sigp_stop (struct kvm_vcpu *vcpu,int action); +static inline int kvm_s390_vcpu_get_memsize (struct kvm_vcpu *vcpu) +{ +return vcpu->arch.sie_block->gmslm + - vcpu->arch.sie_block->gmsor + -VIRTIODESCSPACE +1ul ; +} + +static inline void kvm_s390_vcpu_set_mem (struct kvm_vcpu *vcpu) +{ +struct kvm_memory_slot *mem; + +down_read (&vcpu->kvm->slots_lock); + mem = &vcpu->kvm->memslots[0 ]; + + vcpu->arch.sie_block->gmsor = mem->userspace_addr; + vcpu->arch.sie_block->gmslm = + mem->userspace_addr + + (mem->npages <<PAGE_SHIFT ) + +VIRTIODESCSPACE -1ul ; + +up_read (&vcpu->kvm->slots_lock); +} +/* implemented in priv.c */ int kvm_s390_handle_b2 (struct kvm_vcpu *vcpu);
arch/s390/include/asm/kvm_host.h +1 -3
@@ -1,7 +1,7 @@/* * asm-s390/kvm_host.h - definition for kernel virtual machines on s390 * -* 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)
@@ -226,8 +226,6 @@ struct kvm_vm_stat { };struct kvm_arch { -unsigned long guest_origin; -unsigned long guest_memsize;struct sca_block *sca;debug_info_t *dbf;struct kvm_s390_float_interrupt float_int;
arch/s390/kvm/sigp.c +2 -2
@@ -189,9 +189,9 @@ static int __sigp_set_prefix(struct kvm_/* make sure that the new value is valid memory */ address = address &0x7fffe000u ;if ((copy_from_guest (vcpu, &tmp, - (u64) (address + vcpu->kvm->arch.guest_origin) ,1 )) || + (u64) (address + vcpu->arch.sie_block->gmsor) ,1 )) || (copy_from_guest (vcpu, &tmp, (u64) (address + - vcpu->kvm->arch.guest_origin +PAGE_SIZE ),1 ))) { + vcpu->arch.sie_block->gmsor +PAGE_SIZE ),1 ))) { *reg |=SIGP_STAT_INVALID_PARAMETER ;return 1 ;/* invalid parameter */ }