2017-11-24 22:00:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-03-26 01:47:20 +08:00
|
|
|
/*
|
2017-11-21 23:02:52 +08:00
|
|
|
* hosting IBM Z kernel virtual machines (s390x)
|
2008-03-26 01:47:20 +08:00
|
|
|
*
|
2018-01-23 20:28:40 +08:00
|
|
|
* Copyright IBM Corp. 2008, 2018
|
2008-03-26 01:47:20 +08:00
|
|
|
*
|
|
|
|
|
* Author(s): Carsten Otte <cotte@de.ibm.com>
|
|
|
|
|
* Christian Borntraeger <borntraeger@de.ibm.com>
|
|
|
|
|
* Heiko Carstens <heiko.carstens@de.ibm.com>
|
2009-05-25 19:40:51 +08:00
|
|
|
* Christian Ehrhardt <ehrhardt@de.ibm.com>
|
2012-08-02 22:10:17 +08:00
|
|
|
* Jason J. Herne <jjherne@us.ibm.com>
|
2008-03-26 01:47:20 +08:00
|
|
|
*/
|
|
|
|
|
|
2018-12-03 17:20:22 +08:00
|
|
|
#define KMSG_COMPONENT "kvm-s390"
|
|
|
|
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <linux/compiler.h>
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/fs.h>
|
2009-05-12 23:21:49 +08:00
|
|
|
#include <linux/hrtimer.h>
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/kvm.h>
|
|
|
|
|
#include <linux/kvm_host.h>
|
2016-03-08 18:54:42 +08:00
|
|
|
#include <linux/mman.h>
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <linux/module.h>
|
2017-02-10 04:20:25 +08:00
|
|
|
#include <linux/moduleparam.h>
|
2014-09-03 16:13:53 +08:00
|
|
|
#include <linux/random.h>
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <linux/slab.h>
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
#include <linux/timer.h>
|
2015-02-06 22:01:21 +08:00
|
|
|
#include <linux/vmalloc.h>
|
2015-03-20 00:36:43 +08:00
|
|
|
#include <linux/bitmap.h>
|
2017-02-03 02:15:33 +08:00
|
|
|
#include <linux/sched/signal.h>
|
2016-08-04 23:54:42 +08:00
|
|
|
#include <linux/string.h>
|
2017-02-03 02:15:33 +08:00
|
|
|
|
2010-02-27 05:37:43 +08:00
|
|
|
#include <asm/asm-offsets.h>
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <asm/lowcore.h>
|
2016-05-31 21:06:51 +08:00
|
|
|
#include <asm/stp.h>
|
2008-03-26 01:47:20 +08:00
|
|
|
#include <asm/pgtable.h>
|
2016-03-08 18:49:57 +08:00
|
|
|
#include <asm/gmap.h>
|
2009-03-26 22:24:01 +08:00
|
|
|
#include <asm/nmi.h>
|
2012-03-29 01:30:02 +08:00
|
|
|
#include <asm/switch_to.h>
|
2013-07-03 21:18:35 +08:00
|
|
|
#include <asm/isc.h>
|
2012-05-15 20:15:25 +08:00
|
|
|
#include <asm/sclp.h>
|
2016-05-18 22:03:47 +08:00
|
|
|
#include <asm/cpacf.h>
|
- ARM: GICv3 ITS emulation and various fixes. Removal of the old
VGIC implementation.
- s390: support for trapping software breakpoints, nested virtualization
(vSIE), the STHYI opcode, initial extensions for CPU model support.
- MIPS: support for MIPS64 hosts (32-bit guests only) and lots of cleanups,
preliminary to this and the upcoming support for hardware virtualization
extensions.
- x86: support for execute-only mappings in nested EPT; reduced vmexit
latency for TSC deadline timer (by about 30%) on Intel hosts; support for
more than 255 vCPUs.
- PPC: bugfixes.
The ugly bit is the conflicts. A couple of them are simple conflicts due
to 4.7 fixes, but most of them are with other trees. There was definitely
too much reliance on Acked-by here. Some conflicts are for KVM patches
where _I_ gave my Acked-by, but the worst are for this pull request's
patches that touch files outside arch/*/kvm. KVM submaintainers should
probably learn to synchronize better with arch maintainers, with the
latter providing topic branches whenever possible instead of Acked-by.
This is what we do with arch/x86. And I should learn to refuse pull
requests when linux-next sends scary signals, even if that means that
submaintainers have to rebase their branches.
Anyhow, here's the list:
- arch/x86/kvm/vmx.c: handle_pcommit and EXIT_REASON_PCOMMIT was removed
by the nvdimm tree. This tree adds handle_preemption_timer and
EXIT_REASON_PREEMPTION_TIMER at the same place. In general all mentions
of pcommit have to go.
There is also a conflict between a stable fix and this patch, where the
stable fix removed the vmx_create_pml_buffer function and its call.
- virt/kvm/kvm_main.c: kvm_cpu_notifier was removed by the hotplug tree.
This tree adds kvm_io_bus_get_dev at the same place.
- virt/kvm/arm/vgic.c: a few final bugfixes went into 4.7 before the
file was completely removed for 4.8.
- include/linux/irqchip/arm-gic-v3.h: this one is entirely our fault;
this is a change that should have gone in through the irqchip tree and
pulled by kvm-arm. I think I would have rejected this kvm-arm pull
request. The KVM version is the right one, except that it lacks
GITS_BASER_PAGES_SHIFT.
- arch/powerpc: what a mess. For the idle_book3s.S conflict, the KVM
tree is the right one; everything else is trivial. In this case I am
not quite sure what went wrong. The commit that is causing the mess
(fd7bacbca47a, "KVM: PPC: Book3S HV: Fix TB corruption in guest exit
path on HMI interrupt", 2016-05-15) touches both arch/powerpc/kernel/
and arch/powerpc/kvm/. It's large, but at 396 insertions/5 deletions
I guessed that it wasn't really possible to split it and that the 5
deletions wouldn't conflict. That wasn't the case.
- arch/s390: also messy. First is hypfs_diag.c where the KVM tree
moved some code and the s390 tree patched it. You have to reapply the
relevant part of commits 6c22c9863760, plus all of e030c1125eab, to
arch/s390/kernel/diag.c. Or pick the linux-next conflict
resolution from http://marc.info/?l=kvm&m=146717549531603&w=2.
Second, there is a conflict in gmap.c between a stable fix and 4.8.
The KVM version here is the correct one.
I have pushed my resolution at refs/heads/merge-20160802 (commit
3d1f53419842) at git://git.kernel.org/pub/scm/virt/kvm/kvm.git.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.22 (GNU/Linux)
iQEcBAABAgAGBQJXoGm7AAoJEL/70l94x66DugQIAIj703ePAFepB/fCrKHkZZia
SGrsBdvAtNsOhr7FQ5qvvjLxiv/cv7CymeuJivX8H+4kuUHUllDzey+RPHYHD9X7
U6n1PdCH9F15a3IXc8tDjlDdOMNIKJixYuq1UyNZMU6NFwl00+TZf9JF8A2US65b
x/41W98ilL6nNBAsoDVmCLtPNWAqQ3lajaZELGfcqRQ9ZGKcAYOaLFXHv2YHf2XC
qIDMf+slBGSQ66UoATnYV2gAopNlWbZ7n0vO6tE2KyvhHZ1m399aBX1+k8la/0JI
69r+Tz7ZHUSFtmlmyByi5IAB87myy2WQHyAPwj+4vwJkDGPcl0TrupzbG7+T05Y=
=42ti
-----END PGP SIGNATURE-----
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm
Pull KVM updates from Paolo Bonzini:
- ARM: GICv3 ITS emulation and various fixes. Removal of the
old VGIC implementation.
- s390: support for trapping software breakpoints, nested
virtualization (vSIE), the STHYI opcode, initial extensions
for CPU model support.
- MIPS: support for MIPS64 hosts (32-bit guests only) and lots
of cleanups, preliminary to this and the upcoming support for
hardware virtualization extensions.
- x86: support for execute-only mappings in nested EPT; reduced
vmexit latency for TSC deadline timer (by about 30%) on Intel
hosts; support for more than 255 vCPUs.
- PPC: bugfixes.
* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (302 commits)
KVM: PPC: Introduce KVM_CAP_PPC_HTM
MIPS: Select HAVE_KVM for MIPS64_R{2,6}
MIPS: KVM: Reset CP0_PageMask during host TLB flush
MIPS: KVM: Fix ptr->int cast via KVM_GUEST_KSEGX()
MIPS: KVM: Sign extend MFC0/RDHWR results
MIPS: KVM: Fix 64-bit big endian dynamic translation
MIPS: KVM: Fail if ebase doesn't fit in CP0_EBase
MIPS: KVM: Use 64-bit CP0_EBase when appropriate
MIPS: KVM: Set CP0_Status.KX on MIPS64
MIPS: KVM: Make entry code MIPS64 friendly
MIPS: KVM: Use kmap instead of CKSEG0ADDR()
MIPS: KVM: Use virt_to_phys() to get commpage PFN
MIPS: Fix definition of KSEGX() for 64-bit
KVM: VMX: Add VMCS to CPU's loaded VMCSs before VMPTRLD
kvm: x86: nVMX: maintain internal copy of current VMCS
KVM: PPC: Book3S HV: Save/restore TM state in H_CEDE
KVM: PPC: Book3S HV: Pull out TM state save/restore into separate procedures
KVM: arm64: vgic-its: Simplify MAPI error handling
KVM: arm64: vgic-its: Make vgic_its_cmd_handle_mapi similar to other handlers
KVM: arm64: vgic-its: Turn device_id validation into generic ID validation
...
2016-08-03 04:11:27 +08:00
|
|
|
#include <asm/timex.h>
|
2018-09-26 07:16:18 +08:00
|
|
|
#include <asm/ap.h>
|
2008-03-26 01:47:23 +08:00
|
|
|
#include "kvm-s390.h"
|
2008-03-26 01:47:20 +08:00
|
|
|
#include "gaccess.h"
|
|
|
|
|
|
2012-07-23 23:20:29 +08:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
|
#include "trace.h"
|
2012-07-23 23:20:30 +08:00
|
|
|
#include "trace-s390.h"
|
2012-07-23 23:20:29 +08:00
|
|
|
|
2015-02-06 22:01:21 +08:00
|
|
|
#define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */
|
2014-11-25 00:13:46 +08:00
|
|
|
#define LOCAL_IRQS 32
|
|
|
|
|
#define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \
|
|
|
|
|
(KVM_MAX_VCPUS + LOCAL_IRQS))
|
2015-02-06 22:01:21 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
|
2018-03-08 20:48:05 +08:00
|
|
|
#define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM
|
2008-03-26 01:47:20 +08:00
|
|
|
|
|
|
|
|
struct kvm_stats_debugfs_item debugfs_entries[] = {
|
|
|
|
|
{ "userspace_handled", VCPU_STAT(exit_userspace) },
|
2008-05-07 15:22:53 +08:00
|
|
|
{ "exit_null", VCPU_STAT(exit_null) },
|
2008-03-26 01:47:23 +08:00
|
|
|
{ "exit_validity", VCPU_STAT(exit_validity) },
|
|
|
|
|
{ "exit_stop_request", VCPU_STAT(exit_stop_request) },
|
|
|
|
|
{ "exit_external_request", VCPU_STAT(exit_external_request) },
|
2018-02-23 15:57:33 +08:00
|
|
|
{ "exit_io_request", VCPU_STAT(exit_io_request) },
|
2008-03-26 01:47:23 +08:00
|
|
|
{ "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "exit_instruction", VCPU_STAT(exit_instruction) },
|
2016-05-06 21:33:06 +08:00
|
|
|
{ "exit_pei", VCPU_STAT(exit_pei) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
|
|
|
|
|
{ "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
|
2016-05-09 20:14:01 +08:00
|
|
|
{ "exit_operation_exception", VCPU_STAT(exit_operation_exception) },
|
kvm: add halt_poll_ns module parameter
This patch introduces a new module parameter for the KVM module; when it
is present, KVM attempts a bit of polling on every HLT before scheduling
itself out via kvm_vcpu_block.
This parameter helps a lot for latency-bound workloads---in particular
I tested it with O_DSYNC writes with a battery-backed disk in the host.
In this case, writes are fast (because the data doesn't have to go all
the way to the platters) but they cannot be merged by either the host or
the guest. KVM's performance here is usually around 30% of bare metal,
or 50% if you use cache=directsync or cache=writethrough (these
parameters avoid that the guest sends pointless flush requests, and
at the same time they are not slow because of the battery-backed cache).
The bad performance happens because on every halt the host CPU decides
to halt itself too. When the interrupt comes, the vCPU thread is then
migrated to a new physical CPU, and in general the latency is horrible
because the vCPU thread has to be scheduled back in.
With this patch performance reaches 60-65% of bare metal and, more
important, 99% of what you get if you use idle=poll in the guest. This
means that the tunable gets rid of this particular bottleneck, and more
work can be done to improve performance in the kernel or QEMU.
Of course there is some price to pay; every time an otherwise idle vCPUs
is interrupted by an interrupt, it will poll unnecessarily and thus
impose a little load on the host. The above results were obtained with
a mostly random value of the parameter (500000), and the load was around
1.5-2.5% CPU usage on one of the host's core for each idle guest vCPU.
The patch also adds a new stat, /sys/kernel/debug/kvm/halt_successful_poll,
that can be used to tune the parameter. It counts how many HLT
instructions received an interrupt during the polling period; each
successful poll avoids that Linux schedules the VCPU thread out and back
in, and may also avoid a likely trip to C1 and back for the physical CPU.
While the VM is idle, a Linux 4 VCPU VM halts around 10 times per second.
Of these halts, almost all are failed polls. During the benchmark,
instead, basically all halts end within the polling period, except a more
or less constant stream of 50 per second coming from vCPUs that are not
running the benchmark. The wasted time is thus very low. Things may
be slightly different for Windows VMs, which have a ~10 ms timer tick.
The effect is also visible on Marcelo's recently-introduced latency
test for the TSC deadline timer. Though of course a non-RT kernel has
awful latency bounds, the latency of the timer is around 8000-10000 clock
cycles compared to 20000-120000 without setting halt_poll_ns. For the TSC
deadline timer, thus, the effect is both a smaller average latency and
a smaller variance.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-02-05 01:20:58 +08:00
|
|
|
{ "halt_successful_poll", VCPU_STAT(halt_successful_poll) },
|
2015-09-16 00:27:57 +08:00
|
|
|
{ "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) },
|
2016-05-13 18:16:35 +08:00
|
|
|
{ "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) },
|
2014-07-11 16:00:43 +08:00
|
|
|
{ "halt_wakeup", VCPU_STAT(halt_wakeup) },
|
2008-07-25 21:52:44 +08:00
|
|
|
{ "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "instruction_lctl", VCPU_STAT(instruction_lctl) },
|
2014-01-23 17:47:13 +08:00
|
|
|
{ "instruction_stctl", VCPU_STAT(instruction_stctl) },
|
|
|
|
|
{ "instruction_stctg", VCPU_STAT(instruction_stctg) },
|
2018-03-08 20:48:05 +08:00
|
|
|
{ "deliver_ckc", VCPU_STAT(deliver_ckc) },
|
|
|
|
|
{ "deliver_cputm", VCPU_STAT(deliver_cputm) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
|
2011-10-18 18:27:15 +08:00
|
|
|
{ "deliver_external_call", VCPU_STAT(deliver_external_call) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
|
2018-03-08 20:48:05 +08:00
|
|
|
{ "deliver_virtio", VCPU_STAT(deliver_virtio) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
|
|
|
|
|
{ "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
|
|
|
|
|
{ "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
|
2018-03-08 20:48:05 +08:00
|
|
|
{ "deliver_program", VCPU_STAT(deliver_program) },
|
|
|
|
|
{ "deliver_io", VCPU_STAT(deliver_io) },
|
2018-03-02 18:56:47 +08:00
|
|
|
{ "deliver_machine_check", VCPU_STAT(deliver_machine_check) },
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
{ "exit_wait_state", VCPU_STAT(exit_wait_state) },
|
2018-03-08 20:48:05 +08:00
|
|
|
{ "inject_ckc", VCPU_STAT(inject_ckc) },
|
|
|
|
|
{ "inject_cputm", VCPU_STAT(inject_cputm) },
|
|
|
|
|
{ "inject_external_call", VCPU_STAT(inject_external_call) },
|
|
|
|
|
{ "inject_float_mchk", VM_STAT(inject_float_mchk) },
|
|
|
|
|
{ "inject_emergency_signal", VCPU_STAT(inject_emergency_signal) },
|
|
|
|
|
{ "inject_io", VM_STAT(inject_io) },
|
|
|
|
|
{ "inject_mchk", VCPU_STAT(inject_mchk) },
|
|
|
|
|
{ "inject_pfault_done", VM_STAT(inject_pfault_done) },
|
|
|
|
|
{ "inject_program", VCPU_STAT(inject_program) },
|
|
|
|
|
{ "inject_restart", VCPU_STAT(inject_restart) },
|
|
|
|
|
{ "inject_service_signal", VM_STAT(inject_service_signal) },
|
|
|
|
|
{ "inject_set_prefix", VCPU_STAT(inject_set_prefix) },
|
|
|
|
|
{ "inject_stop_signal", VCPU_STAT(inject_stop_signal) },
|
|
|
|
|
{ "inject_pfault_init", VCPU_STAT(inject_pfault_init) },
|
|
|
|
|
{ "inject_virtio", VM_STAT(inject_virtio) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_epsw", VCPU_STAT(instruction_epsw) },
|
|
|
|
|
{ "instruction_gs", VCPU_STAT(instruction_gs) },
|
|
|
|
|
{ "instruction_io_other", VCPU_STAT(instruction_io_other) },
|
|
|
|
|
{ "instruction_lpsw", VCPU_STAT(instruction_lpsw) },
|
|
|
|
|
{ "instruction_lpswe", VCPU_STAT(instruction_lpswe) },
|
2013-06-12 19:54:53 +08:00
|
|
|
{ "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_ptff", VCPU_STAT(instruction_ptff) },
|
2008-03-26 01:47:29 +08:00
|
|
|
{ "instruction_stidp", VCPU_STAT(instruction_stidp) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_sck", VCPU_STAT(instruction_sck) },
|
|
|
|
|
{ "instruction_sckpf", VCPU_STAT(instruction_sckpf) },
|
2008-03-26 01:47:29 +08:00
|
|
|
{ "instruction_spx", VCPU_STAT(instruction_spx) },
|
|
|
|
|
{ "instruction_stpx", VCPU_STAT(instruction_stpx) },
|
|
|
|
|
{ "instruction_stap", VCPU_STAT(instruction_stap) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_iske", VCPU_STAT(instruction_iske) },
|
|
|
|
|
{ "instruction_ri", VCPU_STAT(instruction_ri) },
|
|
|
|
|
{ "instruction_rrbe", VCPU_STAT(instruction_rrbe) },
|
|
|
|
|
{ "instruction_sske", VCPU_STAT(instruction_sske) },
|
2014-01-10 21:33:28 +08:00
|
|
|
{ "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) },
|
2013-04-17 23:36:29 +08:00
|
|
|
{ "instruction_essa", VCPU_STAT(instruction_essa) },
|
2008-03-26 01:47:29 +08:00
|
|
|
{ "instruction_stsi", VCPU_STAT(instruction_stsi) },
|
|
|
|
|
{ "instruction_stfl", VCPU_STAT(instruction_stfl) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_tb", VCPU_STAT(instruction_tb) },
|
|
|
|
|
{ "instruction_tpi", VCPU_STAT(instruction_tpi) },
|
2011-07-24 16:48:17 +08:00
|
|
|
{ "instruction_tprot", VCPU_STAT(instruction_tprot) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_tsch", VCPU_STAT(instruction_tsch) },
|
2016-05-23 21:11:58 +08:00
|
|
|
{ "instruction_sthyi", VCPU_STAT(instruction_sthyi) },
|
2015-07-08 19:19:48 +08:00
|
|
|
{ "instruction_sie", VCPU_STAT(instruction_sie) },
|
2008-03-26 01:47:31 +08:00
|
|
|
{ "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
|
2011-11-17 18:00:42 +08:00
|
|
|
{ "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
|
2011-10-18 18:27:15 +08:00
|
|
|
{ "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
|
2008-03-26 01:47:31 +08:00
|
|
|
{ "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
|
2014-05-23 18:25:11 +08:00
|
|
|
{ "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) },
|
|
|
|
|
{ "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) },
|
2008-03-26 01:47:31 +08:00
|
|
|
{ "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
|
2014-05-23 18:25:11 +08:00
|
|
|
{ "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) },
|
|
|
|
|
{ "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) },
|
2015-02-12 22:06:34 +08:00
|
|
|
{ "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) },
|
2008-03-26 01:47:31 +08:00
|
|
|
{ "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
|
|
|
|
|
{ "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
|
|
|
|
|
{ "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
|
2014-05-23 18:25:11 +08:00
|
|
|
{ "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) },
|
|
|
|
|
{ "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) },
|
|
|
|
|
{ "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) },
|
2018-01-24 19:27:01 +08:00
|
|
|
{ "instruction_diag_10", VCPU_STAT(diagnose_10) },
|
|
|
|
|
{ "instruction_diag_44", VCPU_STAT(diagnose_44) },
|
|
|
|
|
{ "instruction_diag_9c", VCPU_STAT(diagnose_9c) },
|
|
|
|
|
{ "instruction_diag_258", VCPU_STAT(diagnose_258) },
|
|
|
|
|
{ "instruction_diag_308", VCPU_STAT(diagnose_308) },
|
|
|
|
|
{ "instruction_diag_500", VCPU_STAT(diagnose_500) },
|
2018-01-23 20:28:40 +08:00
|
|
|
{ "instruction_diag_other", VCPU_STAT(diagnose_other) },
|
2008-03-26 01:47:20 +08:00
|
|
|
{ NULL }
|
|
|
|
|
};
|
|
|
|
|
|
2016-07-27 03:29:44 +08:00
|
|
|
struct kvm_s390_tod_clock_ext {
|
|
|
|
|
__u8 epoch_idx;
|
|
|
|
|
__u64 tod;
|
|
|
|
|
__u8 reserved[7];
|
|
|
|
|
} __packed;
|
|
|
|
|
|
2016-02-02 22:41:22 +08:00
|
|
|
/* allow nested virtualization in KVM (if enabled by user space) */
|
|
|
|
|
static int nested;
|
|
|
|
|
module_param(nested, int, S_IRUGO);
|
|
|
|
|
MODULE_PARM_DESC(nested, "Nested virtualization support");
|
|
|
|
|
|
2018-07-13 18:28:31 +08:00
|
|
|
/* allow 1m huge page guest backing, if !nested */
|
|
|
|
|
static int hpage;
|
|
|
|
|
module_param(hpage, int, 0444);
|
|
|
|
|
MODULE_PARM_DESC(hpage, "1m huge page backing support");
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2018-02-10 00:26:29 +08:00
|
|
|
/*
|
|
|
|
|
* For now we handle at most 16 double words as this is what the s390 base
|
|
|
|
|
* kernel handles and stores in the prefix page. If we ever need to go beyond
|
|
|
|
|
* this, this requires changes to code, but the external uapi can stay.
|
|
|
|
|
*/
|
|
|
|
|
#define SIZE_INTERNAL 16
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Base feature mask that defines default mask for facilities. Consists of the
|
|
|
|
|
* defines in FACILITIES_KVM and the non-hypervisor managed bits.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned long kvm_s390_fac_base[SIZE_INTERNAL] = { FACILITIES_KVM };
|
|
|
|
|
/*
|
|
|
|
|
* Extended feature mask. Consists of the defines in FACILITIES_KVM_CPUMODEL
|
|
|
|
|
* and defines the facilities that can be enabled via a cpu model.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned long kvm_s390_fac_ext[SIZE_INTERNAL] = { FACILITIES_KVM_CPUMODEL };
|
|
|
|
|
|
|
|
|
|
static unsigned long kvm_s390_fac_size(void)
|
2013-07-26 21:04:04 +08:00
|
|
|
{
|
2018-02-10 00:26:29 +08:00
|
|
|
BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_MASK_SIZE_U64);
|
|
|
|
|
BUILD_BUG_ON(SIZE_INTERNAL > S390_ARCH_FAC_LIST_SIZE_U64);
|
|
|
|
|
BUILD_BUG_ON(SIZE_INTERNAL * sizeof(unsigned long) >
|
|
|
|
|
sizeof(S390_lowcore.stfle_fac_list));
|
|
|
|
|
|
|
|
|
|
return SIZE_INTERNAL;
|
2013-07-26 21:04:04 +08:00
|
|
|
}
|
|
|
|
|
|
2015-03-20 00:36:43 +08:00
|
|
|
/* available cpu features supported by kvm */
|
|
|
|
|
static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS);
|
2016-05-18 22:03:47 +08:00
|
|
|
/* available subfunctions indicated via query / "test bit" */
|
|
|
|
|
static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc;
|
2015-03-20 00:36:43 +08:00
|
|
|
|
2015-02-02 22:42:51 +08:00
|
|
|
static struct gmap_notifier gmap_notifier;
|
2015-07-08 19:19:48 +08:00
|
|
|
static struct gmap_notifier vsie_gmap_notifier;
|
2015-07-22 21:50:58 +08:00
|
|
|
debug_info_t *kvm_s390_dbf;
|
2015-02-02 22:42:51 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
/* Section: not file related */
|
2014-08-28 21:13:03 +08:00
|
|
|
int kvm_arch_hardware_enable(void)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
|
|
|
|
/* every s390 is virtualization enabled ;-) */
|
2009-09-15 17:37:46 +08:00
|
|
|
return 0;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2016-03-08 18:52:54 +08:00
|
|
|
static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start,
|
|
|
|
|
unsigned long end);
|
2013-05-17 20:41:36 +08:00
|
|
|
|
2018-02-07 19:46:45 +08:00
|
|
|
static void kvm_clock_sync_scb(struct kvm_s390_sie_block *scb, u64 delta)
|
|
|
|
|
{
|
|
|
|
|
u8 delta_idx = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The TOD jumps by delta, we have to compensate this by adding
|
|
|
|
|
* -delta to the epoch.
|
|
|
|
|
*/
|
|
|
|
|
delta = -delta;
|
|
|
|
|
|
|
|
|
|
/* sign-extension - we're adding to signed values below */
|
|
|
|
|
if ((s64)delta < 0)
|
|
|
|
|
delta_idx = -1;
|
|
|
|
|
|
|
|
|
|
scb->epoch += delta;
|
|
|
|
|
if (scb->ecd & ECD_MEF) {
|
|
|
|
|
scb->epdx += delta_idx;
|
|
|
|
|
if (scb->epoch < delta)
|
|
|
|
|
scb->epdx += 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-13 16:58:41 +08:00
|
|
|
/*
|
|
|
|
|
* This callback is executed during stop_machine(). All CPUs are therefore
|
|
|
|
|
* temporarily stopped. In order not to change guest behavior, we have to
|
|
|
|
|
* disable preemption whenever we touch the epoch of kvm and the VCPUs,
|
|
|
|
|
* so a CPU won't be stopped while calculating with the epoch.
|
|
|
|
|
*/
|
|
|
|
|
static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val,
|
|
|
|
|
void *v)
|
|
|
|
|
{
|
|
|
|
|
struct kvm *kvm;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
int i;
|
|
|
|
|
unsigned long long *delta = v;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(kvm, &vm_list, vm_list) {
|
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
2018-02-07 19:46:45 +08:00
|
|
|
kvm_clock_sync_scb(vcpu->arch.sie_block, *delta);
|
|
|
|
|
if (i == 0) {
|
|
|
|
|
kvm->arch.epoch = vcpu->arch.sie_block->epoch;
|
|
|
|
|
kvm->arch.epdx = vcpu->arch.sie_block->epdx;
|
|
|
|
|
}
|
2016-02-15 16:42:25 +08:00
|
|
|
if (vcpu->arch.cputm_enabled)
|
|
|
|
|
vcpu->arch.cputm_start += *delta;
|
2015-10-29 17:30:36 +08:00
|
|
|
if (vcpu->arch.vsie_block)
|
2018-02-07 19:46:45 +08:00
|
|
|
kvm_clock_sync_scb(vcpu->arch.vsie_block,
|
|
|
|
|
*delta);
|
2015-05-13 16:58:41 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct notifier_block kvm_clock_notifier = {
|
|
|
|
|
.notifier_call = kvm_clock_sync,
|
|
|
|
|
};
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
int kvm_arch_hardware_setup(void)
|
|
|
|
|
{
|
2013-05-17 20:41:36 +08:00
|
|
|
gmap_notifier.notifier_call = kvm_gmap_notifier;
|
2016-03-08 18:54:42 +08:00
|
|
|
gmap_register_pte_notifier(&gmap_notifier);
|
2015-07-08 19:19:48 +08:00
|
|
|
vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier;
|
|
|
|
|
gmap_register_pte_notifier(&vsie_gmap_notifier);
|
2015-05-13 16:58:41 +08:00
|
|
|
atomic_notifier_chain_register(&s390_epoch_delta_notifier,
|
|
|
|
|
&kvm_clock_notifier);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_hardware_unsetup(void)
|
|
|
|
|
{
|
2016-03-08 18:54:42 +08:00
|
|
|
gmap_unregister_pte_notifier(&gmap_notifier);
|
2015-07-08 19:19:48 +08:00
|
|
|
gmap_unregister_pte_notifier(&vsie_gmap_notifier);
|
2015-05-13 16:58:41 +08:00
|
|
|
atomic_notifier_chain_unregister(&s390_epoch_delta_notifier,
|
|
|
|
|
&kvm_clock_notifier);
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2016-01-21 20:22:54 +08:00
|
|
|
static void allow_cpu_feat(unsigned long nr)
|
|
|
|
|
{
|
|
|
|
|
set_bit_inv(nr, kvm_s390_available_cpu_feat);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-18 22:03:47 +08:00
|
|
|
static inline int plo_test_bit(unsigned char nr)
|
|
|
|
|
{
|
|
|
|
|
register unsigned long r0 asm("0") = (unsigned long) nr | 0x100;
|
2016-12-13 21:25:32 +08:00
|
|
|
int cc;
|
2016-05-18 22:03:47 +08:00
|
|
|
|
|
|
|
|
asm volatile(
|
|
|
|
|
/* Parameter registers are ignored for "test bit" */
|
|
|
|
|
" plo 0,0,0,0(0)\n"
|
|
|
|
|
" ipm %0\n"
|
|
|
|
|
" srl %0,28\n"
|
|
|
|
|
: "=d" (cc)
|
|
|
|
|
: "d" (r0)
|
|
|
|
|
: "cc");
|
|
|
|
|
return cc == 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-20 16:04:07 +08:00
|
|
|
static inline void __insn32_query(unsigned int opcode, u8 query[32])
|
|
|
|
|
{
|
|
|
|
|
register unsigned long r0 asm("0") = 0; /* query function */
|
|
|
|
|
register unsigned long r1 asm("1") = (unsigned long) query;
|
|
|
|
|
|
|
|
|
|
asm volatile(
|
|
|
|
|
/* Parameter regs are ignored */
|
|
|
|
|
" .insn rrf,%[opc] << 16,2,4,6,0\n"
|
|
|
|
|
: "=m" (*query)
|
|
|
|
|
: "d" (r0), "a" (r1), [opc] "i" (opcode)
|
|
|
|
|
: "cc");
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-28 17:59:06 +08:00
|
|
|
#define INSN_SORTL 0xb938
|
2018-12-28 17:46:04 +08:00
|
|
|
#define INSN_DFLTCC 0xb939
|
2018-12-28 17:59:06 +08:00
|
|
|
|
2016-01-21 20:22:54 +08:00
|
|
|
static void kvm_s390_cpu_feat_init(void)
|
|
|
|
|
{
|
2016-05-18 22:03:47 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 256; ++i) {
|
|
|
|
|
if (plo_test_bit(i))
|
|
|
|
|
kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (test_facility(28)) /* TOD-clock steering */
|
- ARM: GICv3 ITS emulation and various fixes. Removal of the old
VGIC implementation.
- s390: support for trapping software breakpoints, nested virtualization
(vSIE), the STHYI opcode, initial extensions for CPU model support.
- MIPS: support for MIPS64 hosts (32-bit guests only) and lots of cleanups,
preliminary to this and the upcoming support for hardware virtualization
extensions.
- x86: support for execute-only mappings in nested EPT; reduced vmexit
latency for TSC deadline timer (by about 30%) on Intel hosts; support for
more than 255 vCPUs.
- PPC: bugfixes.
The ugly bit is the conflicts. A couple of them are simple conflicts due
to 4.7 fixes, but most of them are with other trees. There was definitely
too much reliance on Acked-by here. Some conflicts are for KVM patches
where _I_ gave my Acked-by, but the worst are for this pull request's
patches that touch files outside arch/*/kvm. KVM submaintainers should
probably learn to synchronize better with arch maintainers, with the
latter providing topic branches whenever possible instead of Acked-by.
This is what we do with arch/x86. And I should learn to refuse pull
requests when linux-next sends scary signals, even if that means that
submaintainers have to rebase their branches.
Anyhow, here's the list:
- arch/x86/kvm/vmx.c: handle_pcommit and EXIT_REASON_PCOMMIT was removed
by the nvdimm tree. This tree adds handle_preemption_timer and
EXIT_REASON_PREEMPTION_TIMER at the same place. In general all mentions
of pcommit have to go.
There is also a conflict between a stable fix and this patch, where the
stable fix removed the vmx_create_pml_buffer function and its call.
- virt/kvm/kvm_main.c: kvm_cpu_notifier was removed by the hotplug tree.
This tree adds kvm_io_bus_get_dev at the same place.
- virt/kvm/arm/vgic.c: a few final bugfixes went into 4.7 before the
file was completely removed for 4.8.
- include/linux/irqchip/arm-gic-v3.h: this one is entirely our fault;
this is a change that should have gone in through the irqchip tree and
pulled by kvm-arm. I think I would have rejected this kvm-arm pull
request. The KVM version is the right one, except that it lacks
GITS_BASER_PAGES_SHIFT.
- arch/powerpc: what a mess. For the idle_book3s.S conflict, the KVM
tree is the right one; everything else is trivial. In this case I am
not quite sure what went wrong. The commit that is causing the mess
(fd7bacbca47a, "KVM: PPC: Book3S HV: Fix TB corruption in guest exit
path on HMI interrupt", 2016-05-15) touches both arch/powerpc/kernel/
and arch/powerpc/kvm/. It's large, but at 396 insertions/5 deletions
I guessed that it wasn't really possible to split it and that the 5
deletions wouldn't conflict. That wasn't the case.
- arch/s390: also messy. First is hypfs_diag.c where the KVM tree
moved some code and the s390 tree patched it. You have to reapply the
relevant part of commits 6c22c9863760, plus all of e030c1125eab, to
arch/s390/kernel/diag.c. Or pick the linux-next conflict
resolution from http://marc.info/?l=kvm&m=146717549531603&w=2.
Second, there is a conflict in gmap.c between a stable fix and 4.8.
The KVM version here is the correct one.
I have pushed my resolution at refs/heads/merge-20160802 (commit
3d1f53419842) at git://git.kernel.org/pub/scm/virt/kvm/kvm.git.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.22 (GNU/Linux)
iQEcBAABAgAGBQJXoGm7AAoJEL/70l94x66DugQIAIj703ePAFepB/fCrKHkZZia
SGrsBdvAtNsOhr7FQ5qvvjLxiv/cv7CymeuJivX8H+4kuUHUllDzey+RPHYHD9X7
U6n1PdCH9F15a3IXc8tDjlDdOMNIKJixYuq1UyNZMU6NFwl00+TZf9JF8A2US65b
x/41W98ilL6nNBAsoDVmCLtPNWAqQ3lajaZELGfcqRQ9ZGKcAYOaLFXHv2YHf2XC
qIDMf+slBGSQ66UoATnYV2gAopNlWbZ7n0vO6tE2KyvhHZ1m399aBX1+k8la/0JI
69r+Tz7ZHUSFtmlmyByi5IAB87myy2WQHyAPwj+4vwJkDGPcl0TrupzbG7+T05Y=
=42ti
-----END PGP SIGNATURE-----
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm
Pull KVM updates from Paolo Bonzini:
- ARM: GICv3 ITS emulation and various fixes. Removal of the
old VGIC implementation.
- s390: support for trapping software breakpoints, nested
virtualization (vSIE), the STHYI opcode, initial extensions
for CPU model support.
- MIPS: support for MIPS64 hosts (32-bit guests only) and lots
of cleanups, preliminary to this and the upcoming support for
hardware virtualization extensions.
- x86: support for execute-only mappings in nested EPT; reduced
vmexit latency for TSC deadline timer (by about 30%) on Intel
hosts; support for more than 255 vCPUs.
- PPC: bugfixes.
* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (302 commits)
KVM: PPC: Introduce KVM_CAP_PPC_HTM
MIPS: Select HAVE_KVM for MIPS64_R{2,6}
MIPS: KVM: Reset CP0_PageMask during host TLB flush
MIPS: KVM: Fix ptr->int cast via KVM_GUEST_KSEGX()
MIPS: KVM: Sign extend MFC0/RDHWR results
MIPS: KVM: Fix 64-bit big endian dynamic translation
MIPS: KVM: Fail if ebase doesn't fit in CP0_EBase
MIPS: KVM: Use 64-bit CP0_EBase when appropriate
MIPS: KVM: Set CP0_Status.KX on MIPS64
MIPS: KVM: Make entry code MIPS64 friendly
MIPS: KVM: Use kmap instead of CKSEG0ADDR()
MIPS: KVM: Use virt_to_phys() to get commpage PFN
MIPS: Fix definition of KSEGX() for 64-bit
KVM: VMX: Add VMCS to CPU's loaded VMCSs before VMPTRLD
kvm: x86: nVMX: maintain internal copy of current VMCS
KVM: PPC: Book3S HV: Save/restore TM state in H_CEDE
KVM: PPC: Book3S HV: Pull out TM state save/restore into separate procedures
KVM: arm64: vgic-its: Simplify MAPI error handling
KVM: arm64: vgic-its: Make vgic_its_cmd_handle_mapi similar to other handlers
KVM: arm64: vgic-its: Turn device_id validation into generic ID validation
...
2016-08-03 04:11:27 +08:00
|
|
|
ptff(kvm_s390_available_subfunc.ptff,
|
|
|
|
|
sizeof(kvm_s390_available_subfunc.ptff),
|
|
|
|
|
PTFF_QAF);
|
2016-05-18 22:03:47 +08:00
|
|
|
|
|
|
|
|
if (test_facility(17)) { /* MSA */
|
2016-08-18 18:59:46 +08:00
|
|
|
__cpacf_query(CPACF_KMAC, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kmac);
|
|
|
|
|
__cpacf_query(CPACF_KMC, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kmc);
|
|
|
|
|
__cpacf_query(CPACF_KM, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.km);
|
|
|
|
|
__cpacf_query(CPACF_KIMD, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kimd);
|
|
|
|
|
__cpacf_query(CPACF_KLMD, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.klmd);
|
2016-05-18 22:03:47 +08:00
|
|
|
}
|
|
|
|
|
if (test_facility(76)) /* MSA3 */
|
2016-08-18 18:59:46 +08:00
|
|
|
__cpacf_query(CPACF_PCKMO, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.pckmo);
|
2016-05-18 22:03:47 +08:00
|
|
|
if (test_facility(77)) { /* MSA4 */
|
2016-08-18 18:59:46 +08:00
|
|
|
__cpacf_query(CPACF_KMCTR, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kmctr);
|
|
|
|
|
__cpacf_query(CPACF_KMF, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kmf);
|
|
|
|
|
__cpacf_query(CPACF_KMO, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kmo);
|
|
|
|
|
__cpacf_query(CPACF_PCC, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.pcc);
|
2016-05-18 22:03:47 +08:00
|
|
|
}
|
|
|
|
|
if (test_facility(57)) /* MSA5 */
|
2017-02-24 17:11:54 +08:00
|
|
|
__cpacf_query(CPACF_PRNO, (cpacf_mask_t *)
|
2016-08-18 18:59:46 +08:00
|
|
|
kvm_s390_available_subfunc.ppno);
|
2016-05-18 22:03:47 +08:00
|
|
|
|
2017-03-20 21:57:42 +08:00
|
|
|
if (test_facility(146)) /* MSA8 */
|
|
|
|
|
__cpacf_query(CPACF_KMA, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kma);
|
|
|
|
|
|
2018-12-28 16:33:35 +08:00
|
|
|
if (test_facility(155)) /* MSA9 */
|
|
|
|
|
__cpacf_query(CPACF_KDSA, (cpacf_mask_t *)
|
|
|
|
|
kvm_s390_available_subfunc.kdsa);
|
|
|
|
|
|
2018-12-28 17:59:06 +08:00
|
|
|
if (test_facility(150)) /* SORTL */
|
|
|
|
|
__insn32_query(INSN_SORTL, kvm_s390_available_subfunc.sortl);
|
|
|
|
|
|
2018-12-28 17:46:04 +08:00
|
|
|
if (test_facility(151)) /* DFLTCC */
|
|
|
|
|
__insn32_query(INSN_DFLTCC, kvm_s390_available_subfunc.dfltcc);
|
|
|
|
|
|
2016-01-21 20:22:54 +08:00
|
|
|
if (MACHINE_HAS_ESOP)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP);
|
2015-07-08 19:19:48 +08:00
|
|
|
/*
|
|
|
|
|
* We need SIE support, ESOP (PROT_READ protection for gmap_shadow),
|
|
|
|
|
* 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing).
|
|
|
|
|
*/
|
|
|
|
|
if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao ||
|
2016-02-02 22:41:22 +08:00
|
|
|
!test_facility(3) || !nested)
|
2015-07-08 19:19:48 +08:00
|
|
|
return;
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2);
|
2015-11-25 18:02:26 +08:00
|
|
|
if (sclp.has_64bscao)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO);
|
2015-11-25 16:59:49 +08:00
|
|
|
if (sclp.has_siif)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF);
|
2015-11-24 23:32:35 +08:00
|
|
|
if (sclp.has_gpere)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE);
|
2015-11-24 23:41:33 +08:00
|
|
|
if (sclp.has_gsls)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS);
|
2015-11-24 23:53:51 +08:00
|
|
|
if (sclp.has_ib)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB);
|
2015-11-24 23:54:37 +08:00
|
|
|
if (sclp.has_cei)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI);
|
2015-11-24 23:56:23 +08:00
|
|
|
if (sclp.has_ibs)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS);
|
2017-02-25 05:12:56 +08:00
|
|
|
if (sclp.has_kss)
|
|
|
|
|
allow_cpu_feat(KVM_S390_VM_CPU_FEAT_KSS);
|
2016-04-13 23:06:50 +08:00
|
|
|
/*
|
|
|
|
|
* KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make
|
|
|
|
|
* all skey handling functions read/set the skey from the PGSTE
|
|
|
|
|
* instead of the real storage key.
|
|
|
|
|
*
|
|
|
|
|
* KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make
|
|
|
|
|
* pages being detected as preserved although they are resident.
|
|
|
|
|
*
|
|
|
|
|
* KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will
|
|
|
|
|
* have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY.
|
|
|
|
|
*
|
|
|
|
|
* For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and
|
|
|
|
|
* KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be
|
|
|
|
|
* correctly shadowed. We can do that for the PGSTE but not for PTE.I.
|
|
|
|
|
*
|
|
|
|
|
* KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We
|
|
|
|
|
* cannot easily shadow the SCA because of the ipte lock.
|
|
|
|
|
*/
|
2016-01-21 20:22:54 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
int kvm_arch_init(void *opaque)
|
|
|
|
|
{
|
2018-11-30 22:32:06 +08:00
|
|
|
int rc;
|
|
|
|
|
|
2015-07-22 21:50:58 +08:00
|
|
|
kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long));
|
|
|
|
|
if (!kvm_s390_dbf)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) {
|
2018-11-30 22:32:06 +08:00
|
|
|
rc = -ENOMEM;
|
|
|
|
|
goto out_debug_unreg;
|
2015-07-22 21:50:58 +08:00
|
|
|
}
|
|
|
|
|
|
2016-01-21 20:22:54 +08:00
|
|
|
kvm_s390_cpu_feat_init();
|
|
|
|
|
|
2014-09-02 17:27:35 +08:00
|
|
|
/* Register floating interrupt controller interface. */
|
2018-11-30 22:32:06 +08:00
|
|
|
rc = kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC);
|
|
|
|
|
if (rc) {
|
2018-12-10 18:15:16 +08:00
|
|
|
pr_err("A FLIC registration call failed with rc=%d\n", rc);
|
2018-11-30 22:32:06 +08:00
|
|
|
goto out_debug_unreg;
|
|
|
|
|
}
|
2019-01-31 16:52:45 +08:00
|
|
|
|
|
|
|
|
rc = kvm_s390_gib_init(GAL_ISC);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto out_gib_destroy;
|
|
|
|
|
|
2018-11-30 22:32:06 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2019-01-31 16:52:45 +08:00
|
|
|
out_gib_destroy:
|
|
|
|
|
kvm_s390_gib_destroy();
|
2018-11-30 22:32:06 +08:00
|
|
|
out_debug_unreg:
|
|
|
|
|
debug_unregister(kvm_s390_dbf);
|
|
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-22 21:50:58 +08:00
|
|
|
void kvm_arch_exit(void)
|
|
|
|
|
{
|
2019-01-31 16:52:40 +08:00
|
|
|
kvm_s390_gib_destroy();
|
2015-07-22 21:50:58 +08:00
|
|
|
debug_unregister(kvm_s390_dbf);
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
/* Section: device related */
|
|
|
|
|
long kvm_arch_dev_ioctl(struct file *filp,
|
|
|
|
|
unsigned int ioctl, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
if (ioctl == KVM_S390_ENABLE_SIE)
|
|
|
|
|
return s390_enable_sie();
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-15 00:27:35 +08:00
|
|
|
int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2009-11-19 21:21:16 +08:00
|
|
|
int r;
|
|
|
|
|
|
2008-07-25 21:49:13 +08:00
|
|
|
switch (ext) {
|
2009-11-19 21:21:16 +08:00
|
|
|
case KVM_CAP_S390_PSW:
|
2011-09-20 23:07:29 +08:00
|
|
|
case KVM_CAP_S390_GMAP:
|
2011-11-17 18:00:44 +08:00
|
|
|
case KVM_CAP_SYNC_MMU:
|
2012-01-04 17:25:29 +08:00
|
|
|
#ifdef CONFIG_KVM_S390_UCONTROL
|
|
|
|
|
case KVM_CAP_S390_UCONTROL:
|
|
|
|
|
#endif
|
2013-10-07 23:11:48 +08:00
|
|
|
case KVM_CAP_ASYNC_PF:
|
2012-01-11 18:20:31 +08:00
|
|
|
case KVM_CAP_SYNC_REGS:
|
2012-05-15 20:15:26 +08:00
|
|
|
case KVM_CAP_ONE_REG:
|
2012-12-20 22:32:11 +08:00
|
|
|
case KVM_CAP_ENABLE_CAP:
|
2012-12-20 22:32:12 +08:00
|
|
|
case KVM_CAP_S390_CSS_SUPPORT:
|
2013-02-28 19:33:21 +08:00
|
|
|
case KVM_CAP_IOEVENTFD:
|
2013-10-07 22:13:45 +08:00
|
|
|
case KVM_CAP_DEVICE_CTRL:
|
2014-07-15 15:54:39 +08:00
|
|
|
case KVM_CAP_S390_IRQCHIP:
|
2014-04-09 19:13:00 +08:00
|
|
|
case KVM_CAP_VM_ATTRIBUTES:
|
2014-04-10 23:35:00 +08:00
|
|
|
case KVM_CAP_MP_STATE:
|
2017-02-08 18:50:15 +08:00
|
|
|
case KVM_CAP_IMMEDIATE_EXIT:
|
2014-11-12 03:57:06 +08:00
|
|
|
case KVM_CAP_S390_INJECT_IRQ:
|
2014-10-09 20:10:13 +08:00
|
|
|
case KVM_CAP_S390_USER_SIGP:
|
2015-01-30 23:55:56 +08:00
|
|
|
case KVM_CAP_S390_USER_STSI:
|
2014-09-23 21:23:01 +08:00
|
|
|
case KVM_CAP_S390_SKEYS:
|
2014-11-25 00:13:46 +08:00
|
|
|
case KVM_CAP_S390_IRQ_STATE:
|
2016-06-21 20:19:51 +08:00
|
|
|
case KVM_CAP_S390_USER_INSTR0:
|
2016-08-04 23:58:47 +08:00
|
|
|
case KVM_CAP_S390_CMMA_MIGRATION:
|
2017-03-10 16:29:38 +08:00
|
|
|
case KVM_CAP_S390_AIS:
|
2017-11-09 17:00:45 +08:00
|
|
|
case KVM_CAP_S390_AIS_MIGRATION:
|
2009-11-19 21:21:16 +08:00
|
|
|
r = 1;
|
|
|
|
|
break;
|
2018-07-13 18:28:31 +08:00
|
|
|
case KVM_CAP_S390_HPAGE_1M:
|
|
|
|
|
r = 0;
|
2018-08-01 18:48:28 +08:00
|
|
|
if (hpage && !kvm_is_ucontrol(kvm))
|
2018-07-13 18:28:31 +08:00
|
|
|
r = 1;
|
|
|
|
|
break;
|
2015-02-06 22:01:21 +08:00
|
|
|
case KVM_CAP_S390_MEM_OP:
|
|
|
|
|
r = MEM_OP_MAX_SIZE;
|
|
|
|
|
break;
|
2012-05-02 16:50:38 +08:00
|
|
|
case KVM_CAP_NR_VCPUS:
|
|
|
|
|
case KVM_CAP_MAX_VCPUS:
|
2015-11-24 20:33:49 +08:00
|
|
|
r = KVM_S390_BSCA_CPU_SLOTS;
|
2016-08-09 04:39:32 +08:00
|
|
|
if (!kvm_s390_use_sca_entries())
|
|
|
|
|
r = KVM_MAX_VCPUS;
|
|
|
|
|
else if (sclp.has_esca && sclp.has_64bscao)
|
2015-11-24 20:33:49 +08:00
|
|
|
r = KVM_S390_ESCA_CPU_SLOTS;
|
2012-05-02 16:50:38 +08:00
|
|
|
break;
|
2013-03-26 00:22:58 +08:00
|
|
|
case KVM_CAP_NR_MEMSLOTS:
|
|
|
|
|
r = KVM_USER_MEM_SLOTS;
|
|
|
|
|
break;
|
2012-05-15 20:15:25 +08:00
|
|
|
case KVM_CAP_S390_COW:
|
2012-11-07 20:17:37 +08:00
|
|
|
r = MACHINE_HAS_ESOP;
|
2012-05-15 20:15:25 +08:00
|
|
|
break;
|
2014-06-09 22:57:26 +08:00
|
|
|
case KVM_CAP_S390_VECTOR_REGISTERS:
|
|
|
|
|
r = MACHINE_HAS_VX;
|
|
|
|
|
break;
|
2016-01-07 18:24:29 +08:00
|
|
|
case KVM_CAP_S390_RI:
|
|
|
|
|
r = test_facility(64);
|
|
|
|
|
break;
|
2016-11-29 14:17:55 +08:00
|
|
|
case KVM_CAP_S390_GS:
|
|
|
|
|
r = test_facility(133);
|
|
|
|
|
break;
|
2018-01-17 21:44:34 +08:00
|
|
|
case KVM_CAP_S390_BPB:
|
|
|
|
|
r = test_facility(82);
|
|
|
|
|
break;
|
2008-07-25 21:49:13 +08:00
|
|
|
default:
|
2009-11-19 21:21:16 +08:00
|
|
|
r = 0;
|
2008-07-25 21:49:13 +08:00
|
|
|
}
|
2009-11-19 21:21:16 +08:00
|
|
|
return r;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2012-08-02 22:10:17 +08:00
|
|
|
static void kvm_s390_sync_dirty_log(struct kvm *kvm,
|
2018-07-17 20:21:22 +08:00
|
|
|
struct kvm_memory_slot *memslot)
|
2012-08-02 22:10:17 +08:00
|
|
|
{
|
2018-07-17 20:21:22 +08:00
|
|
|
int i;
|
2012-08-02 22:10:17 +08:00
|
|
|
gfn_t cur_gfn, last_gfn;
|
2018-07-17 20:21:22 +08:00
|
|
|
unsigned long gaddr, vmaddr;
|
2012-08-02 22:10:17 +08:00
|
|
|
struct gmap *gmap = kvm->arch.gmap;
|
2018-07-17 20:21:22 +08:00
|
|
|
DECLARE_BITMAP(bitmap, _PAGE_ENTRIES);
|
2012-08-02 22:10:17 +08:00
|
|
|
|
2018-07-17 20:21:22 +08:00
|
|
|
/* Loop over all guest segments */
|
|
|
|
|
cur_gfn = memslot->base_gfn;
|
2012-08-02 22:10:17 +08:00
|
|
|
last_gfn = memslot->base_gfn + memslot->npages;
|
2018-07-17 20:21:22 +08:00
|
|
|
for (; cur_gfn <= last_gfn; cur_gfn += _PAGE_ENTRIES) {
|
|
|
|
|
gaddr = gfn_to_gpa(cur_gfn);
|
|
|
|
|
vmaddr = gfn_to_hva_memslot(memslot, cur_gfn);
|
|
|
|
|
if (kvm_is_error_hva(vmaddr))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
bitmap_zero(bitmap, _PAGE_ENTRIES);
|
|
|
|
|
gmap_sync_dirty_log_pmd(gmap, bitmap, gaddr, vmaddr);
|
|
|
|
|
for (i = 0; i < _PAGE_ENTRIES; i++) {
|
|
|
|
|
if (test_bit(i, bitmap))
|
|
|
|
|
mark_page_dirty(kvm, cur_gfn + i);
|
|
|
|
|
}
|
2012-08-02 22:10:17 +08:00
|
|
|
|
2016-02-03 18:12:34 +08:00
|
|
|
if (fatal_signal_pending(current))
|
|
|
|
|
return;
|
2016-02-02 22:15:56 +08:00
|
|
|
cond_resched();
|
2012-08-02 22:10:17 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
/* Section: vm related */
|
2015-04-21 21:31:59 +08:00
|
|
|
static void sca_del_vcpu(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
/*
|
|
|
|
|
* Get (and clear) the dirty memory log for a memory slot.
|
|
|
|
|
*/
|
|
|
|
|
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
|
|
|
|
|
struct kvm_dirty_log *log)
|
|
|
|
|
{
|
2012-08-02 22:10:17 +08:00
|
|
|
int r;
|
|
|
|
|
unsigned long n;
|
2015-05-17 22:20:07 +08:00
|
|
|
struct kvm_memslots *slots;
|
2012-08-02 22:10:17 +08:00
|
|
|
struct kvm_memory_slot *memslot;
|
|
|
|
|
int is_dirty = 0;
|
|
|
|
|
|
2017-02-02 23:39:31 +08:00
|
|
|
if (kvm_is_ucontrol(kvm))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-08-02 22:10:17 +08:00
|
|
|
mutex_lock(&kvm->slots_lock);
|
|
|
|
|
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
if (log->slot >= KVM_USER_MEM_SLOTS)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2015-05-17 22:20:07 +08:00
|
|
|
slots = kvm_memslots(kvm);
|
|
|
|
|
memslot = id_to_memslot(slots, log->slot);
|
2012-08-02 22:10:17 +08:00
|
|
|
r = -ENOENT;
|
|
|
|
|
if (!memslot->dirty_bitmap)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
kvm_s390_sync_dirty_log(kvm, memslot);
|
|
|
|
|
r = kvm_get_dirty_log(kvm, log, &is_dirty);
|
|
|
|
|
if (r)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/* Clear the dirty log */
|
|
|
|
|
if (is_dirty) {
|
|
|
|
|
n = kvm_dirty_bitmap_bytes(memslot);
|
|
|
|
|
memset(memslot->dirty_bitmap, 0, n);
|
|
|
|
|
}
|
|
|
|
|
r = 0;
|
|
|
|
|
out:
|
|
|
|
|
mutex_unlock(&kvm->slots_lock);
|
|
|
|
|
return r;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2016-06-21 20:19:51 +08:00
|
|
|
static void icpt_operexc_on_all_vcpus(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
|
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
|
|
|
kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-16 17:40:56 +08:00
|
|
|
int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
|
2013-10-24 00:26:34 +08:00
|
|
|
{
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
if (cap->flags)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (cap->cap) {
|
2013-07-15 19:36:01 +08:00
|
|
|
case KVM_CAP_S390_IRQCHIP:
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP");
|
2013-07-15 19:36:01 +08:00
|
|
|
kvm->arch.use_irqchip = 1;
|
|
|
|
|
r = 0;
|
|
|
|
|
break;
|
2014-10-09 20:10:13 +08:00
|
|
|
case KVM_CAP_S390_USER_SIGP:
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP");
|
2014-10-09 20:10:13 +08:00
|
|
|
kvm->arch.user_sigp = 1;
|
|
|
|
|
r = 0;
|
|
|
|
|
break;
|
2014-06-09 22:57:26 +08:00
|
|
|
case KVM_CAP_S390_VECTOR_REGISTERS:
|
2015-11-06 19:08:48 +08:00
|
|
|
mutex_lock(&kvm->lock);
|
2016-06-13 20:50:04 +08:00
|
|
|
if (kvm->created_vcpus) {
|
2015-11-06 19:08:48 +08:00
|
|
|
r = -EBUSY;
|
|
|
|
|
} else if (MACHINE_HAS_VX) {
|
2015-12-02 15:53:52 +08:00
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 129);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 129);
|
2016-06-03 20:37:17 +08:00
|
|
|
if (test_facility(134)) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 134);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 134);
|
|
|
|
|
}
|
2016-02-10 17:31:23 +08:00
|
|
|
if (test_facility(135)) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 135);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 135);
|
|
|
|
|
}
|
2018-12-28 16:43:37 +08:00
|
|
|
if (test_facility(148)) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 148);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 148);
|
|
|
|
|
}
|
2018-12-28 16:45:58 +08:00
|
|
|
if (test_facility(152)) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 152);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 152);
|
|
|
|
|
}
|
2015-03-16 23:05:41 +08:00
|
|
|
r = 0;
|
|
|
|
|
} else
|
|
|
|
|
r = -EINVAL;
|
2015-11-06 19:08:48 +08:00
|
|
|
mutex_unlock(&kvm->lock);
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s",
|
|
|
|
|
r ? "(not available)" : "(success)");
|
2014-06-09 22:57:26 +08:00
|
|
|
break;
|
2016-01-07 18:24:29 +08:00
|
|
|
case KVM_CAP_S390_RI:
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
mutex_lock(&kvm->lock);
|
2016-06-13 20:50:04 +08:00
|
|
|
if (kvm->created_vcpus) {
|
2016-01-07 18:24:29 +08:00
|
|
|
r = -EBUSY;
|
|
|
|
|
} else if (test_facility(64)) {
|
2015-12-02 15:53:52 +08:00
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 64);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 64);
|
2016-01-07 18:24:29 +08:00
|
|
|
r = 0;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s",
|
|
|
|
|
r ? "(not available)" : "(success)");
|
|
|
|
|
break;
|
2017-03-10 16:29:38 +08:00
|
|
|
case KVM_CAP_S390_AIS:
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
if (kvm->created_vcpus) {
|
|
|
|
|
r = -EBUSY;
|
|
|
|
|
} else {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 72);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 72);
|
|
|
|
|
r = 0;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
VM_EVENT(kvm, 3, "ENABLE: AIS %s",
|
|
|
|
|
r ? "(not available)" : "(success)");
|
|
|
|
|
break;
|
2016-11-29 14:17:55 +08:00
|
|
|
case KVM_CAP_S390_GS:
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
mutex_lock(&kvm->lock);
|
2017-11-16 22:12:52 +08:00
|
|
|
if (kvm->created_vcpus) {
|
2016-11-29 14:17:55 +08:00
|
|
|
r = -EBUSY;
|
|
|
|
|
} else if (test_facility(133)) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 133);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 133);
|
|
|
|
|
r = 0;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
VM_EVENT(kvm, 3, "ENABLE: CAP_S390_GS %s",
|
|
|
|
|
r ? "(not available)" : "(success)");
|
|
|
|
|
break;
|
2018-07-13 18:28:31 +08:00
|
|
|
case KVM_CAP_S390_HPAGE_1M:
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
if (kvm->created_vcpus)
|
|
|
|
|
r = -EBUSY;
|
2018-08-01 18:48:28 +08:00
|
|
|
else if (!hpage || kvm->arch.use_cmma || kvm_is_ucontrol(kvm))
|
2018-07-13 18:28:31 +08:00
|
|
|
r = -EINVAL;
|
|
|
|
|
else {
|
|
|
|
|
r = 0;
|
2018-08-30 22:14:18 +08:00
|
|
|
down_write(&kvm->mm->mmap_sem);
|
2018-07-13 18:28:31 +08:00
|
|
|
kvm->mm->context.allow_gmap_hpage_1m = 1;
|
2018-08-30 22:14:18 +08:00
|
|
|
up_write(&kvm->mm->mmap_sem);
|
2018-07-13 18:28:31 +08:00
|
|
|
/*
|
|
|
|
|
* We might have to create fake 4k page
|
|
|
|
|
* tables. To avoid that the hardware works on
|
|
|
|
|
* stale PGSTEs, we emulate these instructions.
|
|
|
|
|
*/
|
|
|
|
|
kvm->arch.use_skf = 0;
|
|
|
|
|
kvm->arch.use_pfmfi = 0;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
VM_EVENT(kvm, 3, "ENABLE: CAP_S390_HPAGE %s",
|
|
|
|
|
r ? "(not available)" : "(success)");
|
|
|
|
|
break;
|
2015-01-30 23:55:56 +08:00
|
|
|
case KVM_CAP_S390_USER_STSI:
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI");
|
2015-01-30 23:55:56 +08:00
|
|
|
kvm->arch.user_stsi = 1;
|
|
|
|
|
r = 0;
|
|
|
|
|
break;
|
2016-06-21 20:19:51 +08:00
|
|
|
case KVM_CAP_S390_USER_INSTR0:
|
|
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0");
|
|
|
|
|
kvm->arch.user_instr0 = 1;
|
|
|
|
|
icpt_operexc_on_all_vcpus(kvm);
|
|
|
|
|
r = 0;
|
|
|
|
|
break;
|
2013-10-24 00:26:34 +08:00
|
|
|
default:
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-31 21:10:41 +08:00
|
|
|
static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_MEM_LIMIT_SIZE:
|
|
|
|
|
ret = 0;
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes",
|
2014-12-02 00:24:42 +08:00
|
|
|
kvm->arch.mem_limit);
|
|
|
|
|
if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr))
|
2014-10-31 21:10:41 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
|
2014-04-09 19:13:00 +08:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
unsigned int idx;
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_MEM_ENABLE_CMMA:
|
2016-03-03 16:48:47 +08:00
|
|
|
ret = -ENXIO;
|
2015-11-24 20:53:04 +08:00
|
|
|
if (!sclp.has_cmma)
|
2015-05-07 21:41:57 +08:00
|
|
|
break;
|
|
|
|
|
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support");
|
2014-04-09 19:13:00 +08:00
|
|
|
mutex_lock(&kvm->lock);
|
2018-07-13 18:28:31 +08:00
|
|
|
if (kvm->created_vcpus)
|
|
|
|
|
ret = -EBUSY;
|
|
|
|
|
else if (kvm->mm->context.allow_gmap_hpage_1m)
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
else {
|
2014-04-09 19:13:00 +08:00
|
|
|
kvm->arch.use_cmma = 1;
|
2018-02-16 19:16:14 +08:00
|
|
|
/* Not compatible with cmma. */
|
|
|
|
|
kvm->arch.use_pfmfi = 0;
|
2014-04-09 19:13:00 +08:00
|
|
|
ret = 0;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_MEM_CLR_CMMA:
|
2016-03-03 16:48:47 +08:00
|
|
|
ret = -ENXIO;
|
|
|
|
|
if (!sclp.has_cmma)
|
|
|
|
|
break;
|
2015-06-18 19:17:11 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
if (!kvm->arch.use_cmma)
|
|
|
|
|
break;
|
|
|
|
|
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "RESET: CMMA states");
|
2014-04-09 19:13:00 +08:00
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
idx = srcu_read_lock(&kvm->srcu);
|
2014-10-23 18:07:14 +08:00
|
|
|
s390_reset_cmma(kvm->arch.gmap->mm);
|
2014-04-09 19:13:00 +08:00
|
|
|
srcu_read_unlock(&kvm->srcu, idx);
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
2014-10-31 21:10:41 +08:00
|
|
|
case KVM_S390_VM_MEM_LIMIT_SIZE: {
|
|
|
|
|
unsigned long new_limit;
|
|
|
|
|
|
|
|
|
|
if (kvm_is_ucontrol(kvm))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (get_user(new_limit, (u64 __user *)attr->addr))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2014-12-02 00:24:42 +08:00
|
|
|
if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT &&
|
|
|
|
|
new_limit > kvm->arch.mem_limit)
|
2014-10-31 21:10:41 +08:00
|
|
|
return -E2BIG;
|
|
|
|
|
|
2014-12-02 00:24:42 +08:00
|
|
|
if (!new_limit)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2016-03-08 18:55:04 +08:00
|
|
|
/* gmap_create takes last usable address */
|
2014-12-02 00:24:42 +08:00
|
|
|
if (new_limit != KVM_S390_NO_MEM_LIMIT)
|
|
|
|
|
new_limit -= 1;
|
|
|
|
|
|
2014-10-31 21:10:41 +08:00
|
|
|
ret = -EBUSY;
|
|
|
|
|
mutex_lock(&kvm->lock);
|
2016-06-13 20:50:04 +08:00
|
|
|
if (!kvm->created_vcpus) {
|
2016-03-08 18:55:04 +08:00
|
|
|
/* gmap_create will round the limit up */
|
|
|
|
|
struct gmap *new = gmap_create(current->mm, new_limit);
|
2014-10-31 21:10:41 +08:00
|
|
|
|
|
|
|
|
if (!new) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
} else {
|
2016-03-08 18:55:04 +08:00
|
|
|
gmap_remove(kvm->arch.gmap);
|
2014-10-31 21:10:41 +08:00
|
|
|
new->private = kvm;
|
|
|
|
|
kvm->arch.gmap = new;
|
|
|
|
|
ret = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2014-12-02 00:24:42 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit);
|
|
|
|
|
VM_EVENT(kvm, 3, "New guest asce: 0x%pK",
|
|
|
|
|
(void *) kvm->arch.gmap->asce);
|
2014-10-31 21:10:41 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2014-04-09 19:13:00 +08:00
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-03 16:13:53 +08:00
|
|
|
static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
2018-04-22 23:37:03 +08:00
|
|
|
void kvm_s390_vcpu_crypto_reset_all(struct kvm *kvm)
|
2014-09-03 16:13:53 +08:00
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
int i;
|
|
|
|
|
|
2018-04-22 23:37:03 +08:00
|
|
|
kvm_s390_vcpu_block_all(kvm);
|
|
|
|
|
|
2018-09-26 07:16:17 +08:00
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
2018-04-22 23:37:03 +08:00
|
|
|
kvm_s390_vcpu_crypto_setup(vcpu);
|
2018-09-26 07:16:17 +08:00
|
|
|
/* recreate the shadow crycb by leaving the VSIE handler */
|
|
|
|
|
kvm_s390_sync_request(KVM_REQ_VSIE_RESTART, vcpu);
|
|
|
|
|
}
|
2018-04-22 23:37:03 +08:00
|
|
|
|
|
|
|
|
kvm_s390_vcpu_unblock_all(kvm);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2014-09-03 16:13:53 +08:00
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
|
2018-10-04 20:42:43 +08:00
|
|
|
if (!test_kvm_facility(kvm, 76)) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2018-09-26 07:16:39 +08:00
|
|
|
return -EINVAL;
|
2018-10-04 20:42:43 +08:00
|
|
|
}
|
2014-09-03 16:13:53 +08:00
|
|
|
get_random_bytes(
|
|
|
|
|
kvm->arch.crypto.crycb->aes_wrapping_key_mask,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
|
|
|
|
|
kvm->arch.crypto.aes_kw = 1;
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support");
|
2014-09-03 16:13:53 +08:00
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
|
2018-10-04 20:42:43 +08:00
|
|
|
if (!test_kvm_facility(kvm, 76)) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2018-09-26 07:16:39 +08:00
|
|
|
return -EINVAL;
|
2018-10-04 20:42:43 +08:00
|
|
|
}
|
2014-09-03 16:13:53 +08:00
|
|
|
get_random_bytes(
|
|
|
|
|
kvm->arch.crypto.crycb->dea_wrapping_key_mask,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
|
|
|
|
|
kvm->arch.crypto.dea_kw = 1;
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support");
|
2014-09-03 16:13:53 +08:00
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
|
2018-10-04 20:42:43 +08:00
|
|
|
if (!test_kvm_facility(kvm, 76)) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2018-09-26 07:16:39 +08:00
|
|
|
return -EINVAL;
|
2018-10-04 20:42:43 +08:00
|
|
|
}
|
2014-09-03 16:13:53 +08:00
|
|
|
kvm->arch.crypto.aes_kw = 0;
|
|
|
|
|
memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support");
|
2014-09-03 16:13:53 +08:00
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
|
2018-10-04 20:42:43 +08:00
|
|
|
if (!test_kvm_facility(kvm, 76)) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2018-09-26 07:16:39 +08:00
|
|
|
return -EINVAL;
|
2018-10-04 20:42:43 +08:00
|
|
|
}
|
2014-09-03 16:13:53 +08:00
|
|
|
kvm->arch.crypto.dea_kw = 0;
|
|
|
|
|
memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support");
|
2014-09-03 16:13:53 +08:00
|
|
|
break;
|
2018-09-26 07:16:39 +08:00
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_APIE:
|
|
|
|
|
if (!ap_instructions_available()) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
kvm->arch.crypto.apie = 1;
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_APIE:
|
|
|
|
|
if (!ap_instructions_available()) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
}
|
|
|
|
|
kvm->arch.crypto.apie = 0;
|
|
|
|
|
break;
|
2014-09-03 16:13:53 +08:00
|
|
|
default:
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -ENXIO;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-22 23:37:03 +08:00
|
|
|
kvm_s390_vcpu_crypto_reset_all(kvm);
|
2014-09-03 16:13:53 +08:00
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-04 23:54:42 +08:00
|
|
|
static void kvm_s390_sync_request_broadcast(struct kvm *kvm, int req)
|
|
|
|
|
{
|
|
|
|
|
int cx;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
|
|
|
|
|
kvm_for_each_vcpu(cx, vcpu, kvm)
|
|
|
|
|
kvm_s390_sync_request(req, vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Must be called with kvm->srcu held to avoid races on memslots, and with
|
2017-12-22 17:54:20 +08:00
|
|
|
* kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration.
|
2016-08-04 23:54:42 +08:00
|
|
|
*/
|
|
|
|
|
static int kvm_s390_vm_start_migration(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_memory_slot *ms;
|
|
|
|
|
struct kvm_memslots *slots;
|
2018-05-01 00:33:25 +08:00
|
|
|
unsigned long ram_pages = 0;
|
2016-08-04 23:54:42 +08:00
|
|
|
int slotnr;
|
|
|
|
|
|
|
|
|
|
/* migration mode already enabled */
|
2018-05-01 00:33:25 +08:00
|
|
|
if (kvm->arch.migration_mode)
|
2016-08-04 23:54:42 +08:00
|
|
|
return 0;
|
|
|
|
|
slots = kvm_memslots(kvm);
|
|
|
|
|
if (!slots || !slots->used_slots)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
if (!kvm->arch.use_cmma) {
|
|
|
|
|
kvm->arch.migration_mode = 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
/* mark all the pages in active slots as dirty */
|
|
|
|
|
for (slotnr = 0; slotnr < slots->used_slots; slotnr++) {
|
|
|
|
|
ms = slots->memslots + slotnr;
|
2016-08-04 23:54:42 +08:00
|
|
|
/*
|
2018-05-01 00:33:25 +08:00
|
|
|
* The second half of the bitmap is only used on x86,
|
|
|
|
|
* and would be wasted otherwise, so we put it to good
|
|
|
|
|
* use here to keep track of the state of the storage
|
|
|
|
|
* attributes.
|
2016-08-04 23:54:42 +08:00
|
|
|
*/
|
2018-05-01 00:33:25 +08:00
|
|
|
memset(kvm_second_dirty_bitmap(ms), 0xff, kvm_dirty_bitmap_bytes(ms));
|
|
|
|
|
ram_pages += ms->npages;
|
2016-08-04 23:54:42 +08:00
|
|
|
}
|
2018-05-01 00:33:25 +08:00
|
|
|
atomic64_set(&kvm->arch.cmma_dirty_pages, ram_pages);
|
|
|
|
|
kvm->arch.migration_mode = 1;
|
|
|
|
|
kvm_s390_sync_request_broadcast(kvm, KVM_REQ_START_MIGRATION);
|
2016-08-04 23:54:42 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2017-12-22 17:54:20 +08:00
|
|
|
* Must be called with kvm->slots_lock to avoid races with ourselves and
|
2016-08-04 23:54:42 +08:00
|
|
|
* kvm_s390_vm_start_migration.
|
|
|
|
|
*/
|
|
|
|
|
static int kvm_s390_vm_stop_migration(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
/* migration mode already disabled */
|
2018-05-01 00:33:25 +08:00
|
|
|
if (!kvm->arch.migration_mode)
|
2016-08-04 23:54:42 +08:00
|
|
|
return 0;
|
2018-05-01 00:33:25 +08:00
|
|
|
kvm->arch.migration_mode = 0;
|
|
|
|
|
if (kvm->arch.use_cmma)
|
2016-08-04 23:54:42 +08:00
|
|
|
kvm_s390_sync_request_broadcast(kvm, KVM_REQ_STOP_MIGRATION);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_vm_set_migration(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2017-12-22 17:54:20 +08:00
|
|
|
int res = -ENXIO;
|
2016-08-04 23:54:42 +08:00
|
|
|
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_lock(&kvm->slots_lock);
|
2016-08-04 23:54:42 +08:00
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_MIGRATION_START:
|
|
|
|
|
res = kvm_s390_vm_start_migration(kvm);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_MIGRATION_STOP:
|
|
|
|
|
res = kvm_s390_vm_stop_migration(kvm);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_unlock(&kvm->slots_lock);
|
2016-08-04 23:54:42 +08:00
|
|
|
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_vm_get_migration(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2018-05-01 00:33:25 +08:00
|
|
|
u64 mig = kvm->arch.migration_mode;
|
2016-08-04 23:54:42 +08:00
|
|
|
|
|
|
|
|
if (attr->attr != KVM_S390_VM_MIGRATION_STATUS)
|
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user((void __user *)attr->addr, &mig, sizeof(mig)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-27 03:29:44 +08:00
|
|
|
static int kvm_s390_set_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_tod_clock gtod;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(>od, (void __user *)attr->addr, sizeof(gtod)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-02-07 19:46:43 +08:00
|
|
|
if (!test_kvm_facility(kvm, 139) && gtod.epoch_idx)
|
2016-07-27 03:29:44 +08:00
|
|
|
return -EINVAL;
|
2018-02-07 19:46:43 +08:00
|
|
|
kvm_s390_set_tod_clock(kvm, >od);
|
2016-07-27 03:29:44 +08:00
|
|
|
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx",
|
|
|
|
|
gtod.epoch_idx, gtod.tod);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-25 22:46:02 +08:00
|
|
|
static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
u8 gtod_high;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(>od_high, (void __user *)attr->addr,
|
|
|
|
|
sizeof(gtod_high)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (gtod_high != 0)
|
|
|
|
|
return -EINVAL;
|
2015-10-12 19:27:29 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high);
|
2014-11-25 22:46:02 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2018-02-07 19:46:43 +08:00
|
|
|
struct kvm_s390_vm_tod_clock gtod = { 0 };
|
2014-11-25 22:46:02 +08:00
|
|
|
|
2018-02-07 19:46:43 +08:00
|
|
|
if (copy_from_user(>od.tod, (void __user *)attr->addr,
|
|
|
|
|
sizeof(gtod.tod)))
|
2014-11-25 22:46:02 +08:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-02-07 19:46:43 +08:00
|
|
|
kvm_s390_set_tod_clock(kvm, >od);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod.tod);
|
2014-11-25 22:46:02 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (attr->flags)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (attr->attr) {
|
2016-07-27 03:29:44 +08:00
|
|
|
case KVM_S390_VM_TOD_EXT:
|
|
|
|
|
ret = kvm_s390_set_tod_ext(kvm, attr);
|
|
|
|
|
break;
|
2014-11-25 22:46:02 +08:00
|
|
|
case KVM_S390_VM_TOD_HIGH:
|
|
|
|
|
ret = kvm_s390_set_tod_high(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_TOD_LOW:
|
|
|
|
|
ret = kvm_s390_set_tod_low(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-27 20:36:13 +08:00
|
|
|
static void kvm_s390_get_tod_clock(struct kvm *kvm,
|
|
|
|
|
struct kvm_s390_vm_tod_clock *gtod)
|
2016-07-27 03:29:44 +08:00
|
|
|
{
|
|
|
|
|
struct kvm_s390_tod_clock_ext htod;
|
|
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
|
|
get_tod_clock_ext((char *)&htod);
|
|
|
|
|
|
|
|
|
|
gtod->tod = htod.tod + kvm->arch.epoch;
|
2018-04-27 20:36:13 +08:00
|
|
|
gtod->epoch_idx = 0;
|
|
|
|
|
if (test_kvm_facility(kvm, 139)) {
|
|
|
|
|
gtod->epoch_idx = htod.epoch_idx + kvm->arch.epdx;
|
|
|
|
|
if (gtod->tod < htod.tod)
|
|
|
|
|
gtod->epoch_idx += 1;
|
|
|
|
|
}
|
2016-07-27 03:29:44 +08:00
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_tod_ext(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_tod_clock gtod;
|
|
|
|
|
|
|
|
|
|
memset(>od, 0, sizeof(gtod));
|
2018-04-27 20:36:13 +08:00
|
|
|
kvm_s390_get_tod_clock(kvm, >od);
|
2016-07-27 03:29:44 +08:00
|
|
|
if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx",
|
|
|
|
|
gtod.epoch_idx, gtod.tod);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-25 22:46:02 +08:00
|
|
|
static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
u8 gtod_high = 0;
|
|
|
|
|
|
|
|
|
|
if (copy_to_user((void __user *)attr->addr, >od_high,
|
|
|
|
|
sizeof(gtod_high)))
|
|
|
|
|
return -EFAULT;
|
2015-10-12 19:27:29 +08:00
|
|
|
VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high);
|
2014-11-25 22:46:02 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2015-09-29 22:27:24 +08:00
|
|
|
u64 gtod;
|
2014-11-25 22:46:02 +08:00
|
|
|
|
2015-09-29 22:20:36 +08:00
|
|
|
gtod = kvm_s390_get_tod_clock_fast(kvm);
|
2014-11-25 22:46:02 +08:00
|
|
|
if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod)))
|
|
|
|
|
return -EFAULT;
|
2015-10-12 19:27:29 +08:00
|
|
|
VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod);
|
2014-11-25 22:46:02 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (attr->flags)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (attr->attr) {
|
2016-07-27 03:29:44 +08:00
|
|
|
case KVM_S390_VM_TOD_EXT:
|
|
|
|
|
ret = kvm_s390_get_tod_ext(kvm, attr);
|
|
|
|
|
break;
|
2014-11-25 22:46:02 +08:00
|
|
|
case KVM_S390_VM_TOD_HIGH:
|
|
|
|
|
ret = kvm_s390_get_tod_high(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_TOD_LOW:
|
|
|
|
|
ret = kvm_s390_get_tod_low(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-02 22:49:35 +08:00
|
|
|
static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_processor *proc;
|
2016-04-04 19:59:42 +08:00
|
|
|
u16 lowest_ibc, unblocked_ibc;
|
2015-02-02 22:49:35 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
2016-06-13 20:50:04 +08:00
|
|
|
if (kvm->created_vcpus) {
|
2015-02-02 22:49:35 +08:00
|
|
|
ret = -EBUSY;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
proc = kzalloc(sizeof(*proc), GFP_KERNEL);
|
|
|
|
|
if (!proc) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (!copy_from_user(proc, (void __user *)attr->addr,
|
|
|
|
|
sizeof(*proc))) {
|
2016-04-04 20:27:51 +08:00
|
|
|
kvm->arch.model.cpuid = proc->cpuid;
|
2016-04-04 19:59:42 +08:00
|
|
|
lowest_ibc = sclp.ibc >> 16 & 0xfff;
|
|
|
|
|
unblocked_ibc = sclp.ibc & 0xfff;
|
2016-06-10 15:22:31 +08:00
|
|
|
if (lowest_ibc && proc->ibc) {
|
2016-04-04 19:59:42 +08:00
|
|
|
if (proc->ibc > unblocked_ibc)
|
|
|
|
|
kvm->arch.model.ibc = unblocked_ibc;
|
|
|
|
|
else if (proc->ibc < lowest_ibc)
|
|
|
|
|
kvm->arch.model.ibc = lowest_ibc;
|
|
|
|
|
else
|
|
|
|
|
kvm->arch.model.ibc = proc->ibc;
|
|
|
|
|
}
|
2015-12-02 15:53:52 +08:00
|
|
|
memcpy(kvm->arch.model.fac_list, proc->fac_list,
|
2015-02-02 22:49:35 +08:00
|
|
|
S390_ARCH_FAC_LIST_SIZE_BYTE);
|
2017-01-18 23:01:02 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx",
|
|
|
|
|
kvm->arch.model.ibc,
|
|
|
|
|
kvm->arch.model.cpuid);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx",
|
|
|
|
|
kvm->arch.model.fac_list[0],
|
|
|
|
|
kvm->arch.model.fac_list[1],
|
|
|
|
|
kvm->arch.model.fac_list[2]);
|
2015-02-02 22:49:35 +08:00
|
|
|
} else
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
kfree(proc);
|
|
|
|
|
out:
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-20 00:36:43 +08:00
|
|
|
static int kvm_s390_set_processor_feat(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_feat data;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
if (!bitmap_subset((unsigned long *) data.feat,
|
|
|
|
|
kvm_s390_available_cpu_feat,
|
|
|
|
|
KVM_S390_VM_CPU_FEAT_NR_BITS))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
2017-11-16 19:30:15 +08:00
|
|
|
if (kvm->created_vcpus) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -EBUSY;
|
2015-03-20 00:36:43 +08:00
|
|
|
}
|
2017-11-16 19:30:15 +08:00
|
|
|
bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat,
|
|
|
|
|
KVM_S390_VM_CPU_FEAT_NR_BITS);
|
2015-03-20 00:36:43 +08:00
|
|
|
mutex_unlock(&kvm->lock);
|
2017-11-16 19:30:15 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
|
|
|
|
|
data.feat[0],
|
|
|
|
|
data.feat[1],
|
|
|
|
|
data.feat[2]);
|
|
|
|
|
return 0;
|
2015-03-20 00:36:43 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-18 22:03:47 +08:00
|
|
|
static int kvm_s390_set_processor_subfunc(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2019-02-18 20:48:25 +08:00
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
if (kvm->created_vcpus) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&kvm->arch.model.subfuncs, (void __user *)attr->addr,
|
|
|
|
|
sizeof(struct kvm_s390_vm_cpu_subfunc))) {
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
|
2019-02-21 00:38:42 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest PTFF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMAC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KM subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.km)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.km)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KIMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KLMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest PCKMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMCTR subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest PCC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest PPNO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET: guest KMA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kma)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]);
|
2018-12-28 16:33:35 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest KDSA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]);
|
2018-12-28 17:59:06 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]);
|
2018-12-28 17:46:04 +08:00
|
|
|
VM_EVENT(kvm, 3, "SET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]);
|
2019-02-21 00:38:42 +08:00
|
|
|
|
2019-02-18 20:48:25 +08:00
|
|
|
return 0;
|
2016-05-18 22:03:47 +08:00
|
|
|
}
|
|
|
|
|
|
2015-02-02 22:49:35 +08:00
|
|
|
static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret = -ENXIO;
|
|
|
|
|
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_CPU_PROCESSOR:
|
|
|
|
|
ret = kvm_s390_set_processor(kvm, attr);
|
|
|
|
|
break;
|
2015-03-20 00:36:43 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_FEAT:
|
|
|
|
|
ret = kvm_s390_set_processor_feat(kvm, attr);
|
|
|
|
|
break;
|
2016-05-18 22:03:47 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
|
|
|
|
|
ret = kvm_s390_set_processor_subfunc(kvm, attr);
|
|
|
|
|
break;
|
2015-02-02 22:49:35 +08:00
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_processor *proc;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
proc = kzalloc(sizeof(*proc), GFP_KERNEL);
|
|
|
|
|
if (!proc) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2016-04-04 20:27:51 +08:00
|
|
|
proc->cpuid = kvm->arch.model.cpuid;
|
2015-02-02 22:49:35 +08:00
|
|
|
proc->ibc = kvm->arch.model.ibc;
|
2015-12-02 15:53:52 +08:00
|
|
|
memcpy(&proc->fac_list, kvm->arch.model.fac_list,
|
|
|
|
|
S390_ARCH_FAC_LIST_SIZE_BYTE);
|
2017-01-18 23:01:02 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx",
|
|
|
|
|
kvm->arch.model.ibc,
|
|
|
|
|
kvm->arch.model.cpuid);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx",
|
|
|
|
|
kvm->arch.model.fac_list[0],
|
|
|
|
|
kvm->arch.model.fac_list[1],
|
|
|
|
|
kvm->arch.model.fac_list[2]);
|
2015-02-02 22:49:35 +08:00
|
|
|
if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
kfree(proc);
|
|
|
|
|
out:
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_machine *mach;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
mach = kzalloc(sizeof(*mach), GFP_KERNEL);
|
|
|
|
|
if (!mach) {
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
get_cpu_id((struct cpuid *) &mach->cpuid);
|
2015-05-06 19:18:59 +08:00
|
|
|
mach->ibc = sclp.ibc;
|
2015-12-02 15:53:52 +08:00
|
|
|
memcpy(&mach->fac_mask, kvm->arch.model.fac_mask,
|
2015-02-24 20:51:04 +08:00
|
|
|
S390_ARCH_FAC_LIST_SIZE_BYTE);
|
2015-02-02 22:49:35 +08:00
|
|
|
memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list,
|
2017-01-12 23:25:15 +08:00
|
|
|
sizeof(S390_lowcore.stfle_fac_list));
|
2017-01-18 23:01:02 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx",
|
|
|
|
|
kvm->arch.model.ibc,
|
|
|
|
|
kvm->arch.model.cpuid);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx",
|
|
|
|
|
mach->fac_mask[0],
|
|
|
|
|
mach->fac_mask[1],
|
|
|
|
|
mach->fac_mask[2]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx",
|
|
|
|
|
mach->fac_list[0],
|
|
|
|
|
mach->fac_list[1],
|
|
|
|
|
mach->fac_list[2]);
|
2015-02-02 22:49:35 +08:00
|
|
|
if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach)))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
kfree(mach);
|
|
|
|
|
out:
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-20 00:36:43 +08:00
|
|
|
static int kvm_s390_get_processor_feat(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_feat data;
|
|
|
|
|
|
|
|
|
|
bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat,
|
|
|
|
|
KVM_S390_VM_CPU_FEAT_NR_BITS);
|
|
|
|
|
if (copy_to_user((void __user *)attr->addr, &data, sizeof(data)))
|
|
|
|
|
return -EFAULT;
|
2017-11-16 19:30:15 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
|
|
|
|
|
data.feat[0],
|
|
|
|
|
data.feat[1],
|
|
|
|
|
data.feat[2]);
|
2015-03-20 00:36:43 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_machine_feat(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_vm_cpu_feat data;
|
|
|
|
|
|
|
|
|
|
bitmap_copy((unsigned long *) data.feat,
|
|
|
|
|
kvm_s390_available_cpu_feat,
|
|
|
|
|
KVM_S390_VM_CPU_FEAT_NR_BITS);
|
|
|
|
|
if (copy_to_user((void __user *)attr->addr, &data, sizeof(data)))
|
|
|
|
|
return -EFAULT;
|
2017-11-16 19:30:15 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
|
|
|
|
|
data.feat[0],
|
|
|
|
|
data.feat[1],
|
|
|
|
|
data.feat[2]);
|
2015-03-20 00:36:43 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-18 22:03:47 +08:00
|
|
|
static int kvm_s390_get_processor_subfunc(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2019-02-18 20:48:25 +08:00
|
|
|
if (copy_to_user((void __user *)attr->addr, &kvm->arch.model.subfuncs,
|
|
|
|
|
sizeof(struct kvm_s390_vm_cpu_subfunc)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2019-02-21 00:38:42 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.plo)[3]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest PTFF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ptff)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ptff)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMAC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmac)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmac)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KM subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.km)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.km)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KIMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kimd)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kimd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KLMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.klmd)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.klmd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest PCKMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pckmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMCTR subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmctr)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmf)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmf)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmo)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest PCC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pcc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.pcc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest PPNO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ppno)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.ppno)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: guest KMA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kma)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kma)[1]);
|
2018-12-28 16:33:35 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest KDSA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.kdsa)[1]);
|
2018-12-28 17:59:06 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.sortl)[3]);
|
2018-12-28 17:46:04 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[0],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[1],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[2],
|
|
|
|
|
((unsigned long *) &kvm->arch.model.subfuncs.dfltcc)[3]);
|
2019-02-21 00:38:42 +08:00
|
|
|
|
2019-02-18 20:48:25 +08:00
|
|
|
return 0;
|
2016-05-18 22:03:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_machine_subfunc(struct kvm *kvm,
|
|
|
|
|
struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc,
|
|
|
|
|
sizeof(struct kvm_s390_vm_cpu_subfunc)))
|
|
|
|
|
return -EFAULT;
|
2019-02-21 00:38:42 +08:00
|
|
|
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.plo)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.plo)[1],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.plo)[2],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.plo)[3]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host PTFF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.ptff)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.ptff)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMAC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmac)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmac)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmc)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KM subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.km)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.km)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KIMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kimd)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kimd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KLMD subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.klmd)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.klmd)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host PCKMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.pckmo)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.pckmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMCTR subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmctr)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmctr)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMF subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmf)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmf)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmo)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kmo)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host PCC subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.pcc)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.pcc)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host PPNO subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.ppno)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.ppno)[1]);
|
|
|
|
|
VM_EVENT(kvm, 3, "GET: host KMA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kma)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kma)[1]);
|
2018-12-28 16:33:35 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: host KDSA subfunc 0x%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kdsa)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.kdsa)[1]);
|
2018-12-28 17:59:06 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: host SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.sortl)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.sortl)[1],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.sortl)[2],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.sortl)[3]);
|
2018-12-28 17:46:04 +08:00
|
|
|
VM_EVENT(kvm, 3, "GET: host DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[0],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[1],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[2],
|
|
|
|
|
((unsigned long *) &kvm_s390_available_subfunc.dfltcc)[3]);
|
2019-02-21 00:38:42 +08:00
|
|
|
|
2016-05-18 22:03:47 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
2019-02-18 20:48:25 +08:00
|
|
|
|
2015-02-02 22:49:35 +08:00
|
|
|
static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret = -ENXIO;
|
|
|
|
|
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_CPU_PROCESSOR:
|
|
|
|
|
ret = kvm_s390_get_processor(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CPU_MACHINE:
|
|
|
|
|
ret = kvm_s390_get_machine(kvm, attr);
|
|
|
|
|
break;
|
2015-03-20 00:36:43 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_FEAT:
|
|
|
|
|
ret = kvm_s390_get_processor_feat(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CPU_MACHINE_FEAT:
|
|
|
|
|
ret = kvm_s390_get_machine_feat(kvm, attr);
|
|
|
|
|
break;
|
2016-05-18 22:03:47 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
|
|
|
|
|
ret = kvm_s390_get_processor_subfunc(kvm, attr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_VM_CPU_MACHINE_SUBFUNC:
|
|
|
|
|
ret = kvm_s390_get_machine_subfunc(kvm, attr);
|
|
|
|
|
break;
|
2015-02-02 22:49:35 +08:00
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-09 19:13:00 +08:00
|
|
|
static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
switch (attr->group) {
|
2014-04-09 19:13:00 +08:00
|
|
|
case KVM_S390_VM_MEM_CTRL:
|
2014-10-31 21:10:41 +08:00
|
|
|
ret = kvm_s390_set_mem_control(kvm, attr);
|
2014-04-09 19:13:00 +08:00
|
|
|
break;
|
2014-11-25 22:46:02 +08:00
|
|
|
case KVM_S390_VM_TOD:
|
|
|
|
|
ret = kvm_s390_set_tod(kvm, attr);
|
|
|
|
|
break;
|
2015-02-02 22:49:35 +08:00
|
|
|
case KVM_S390_VM_CPU_MODEL:
|
|
|
|
|
ret = kvm_s390_set_cpu_model(kvm, attr);
|
|
|
|
|
break;
|
2014-09-03 16:13:53 +08:00
|
|
|
case KVM_S390_VM_CRYPTO:
|
|
|
|
|
ret = kvm_s390_vm_set_crypto(kvm, attr);
|
|
|
|
|
break;
|
2016-08-04 23:54:42 +08:00
|
|
|
case KVM_S390_VM_MIGRATION:
|
|
|
|
|
ret = kvm_s390_vm_set_migration(kvm, attr);
|
|
|
|
|
break;
|
2014-04-09 19:13:00 +08:00
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
2014-10-31 21:10:41 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
switch (attr->group) {
|
|
|
|
|
case KVM_S390_VM_MEM_CTRL:
|
|
|
|
|
ret = kvm_s390_get_mem_control(kvm, attr);
|
|
|
|
|
break;
|
2014-11-25 22:46:02 +08:00
|
|
|
case KVM_S390_VM_TOD:
|
|
|
|
|
ret = kvm_s390_get_tod(kvm, attr);
|
|
|
|
|
break;
|
2015-02-02 22:49:35 +08:00
|
|
|
case KVM_S390_VM_CPU_MODEL:
|
|
|
|
|
ret = kvm_s390_get_cpu_model(kvm, attr);
|
|
|
|
|
break;
|
2016-08-04 23:54:42 +08:00
|
|
|
case KVM_S390_VM_MIGRATION:
|
|
|
|
|
ret = kvm_s390_vm_get_migration(kvm, attr);
|
|
|
|
|
break;
|
2014-10-31 21:10:41 +08:00
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
2014-04-09 19:13:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
switch (attr->group) {
|
2014-04-09 19:13:00 +08:00
|
|
|
case KVM_S390_VM_MEM_CTRL:
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_MEM_ENABLE_CMMA:
|
|
|
|
|
case KVM_S390_VM_MEM_CLR_CMMA:
|
2016-03-03 16:48:47 +08:00
|
|
|
ret = sclp.has_cmma ? 0 : -ENXIO;
|
|
|
|
|
break;
|
2014-10-31 21:10:41 +08:00
|
|
|
case KVM_S390_VM_MEM_LIMIT_SIZE:
|
2014-04-09 19:13:00 +08:00
|
|
|
ret = 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2014-11-25 22:46:02 +08:00
|
|
|
case KVM_S390_VM_TOD:
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_TOD_LOW:
|
|
|
|
|
case KVM_S390_VM_TOD_HIGH:
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2015-02-02 22:49:35 +08:00
|
|
|
case KVM_S390_VM_CPU_MODEL:
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_CPU_PROCESSOR:
|
|
|
|
|
case KVM_S390_VM_CPU_MACHINE:
|
2015-03-20 00:36:43 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_FEAT:
|
|
|
|
|
case KVM_S390_VM_CPU_MACHINE_FEAT:
|
2016-05-18 22:03:47 +08:00
|
|
|
case KVM_S390_VM_CPU_MACHINE_SUBFUNC:
|
2019-02-18 20:48:25 +08:00
|
|
|
case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
|
2015-02-02 22:49:35 +08:00
|
|
|
ret = 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2014-09-03 16:13:53 +08:00
|
|
|
case KVM_S390_VM_CRYPTO:
|
|
|
|
|
switch (attr->attr) {
|
|
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
|
|
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
2018-09-26 07:16:39 +08:00
|
|
|
case KVM_S390_VM_CRYPTO_ENABLE_APIE:
|
|
|
|
|
case KVM_S390_VM_CRYPTO_DISABLE_APIE:
|
|
|
|
|
ret = ap_instructions_available() ? 0 : -ENXIO;
|
|
|
|
|
break;
|
2014-09-03 16:13:53 +08:00
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2016-08-04 23:54:42 +08:00
|
|
|
case KVM_S390_VM_MIGRATION:
|
|
|
|
|
ret = 0;
|
|
|
|
|
break;
|
2014-04-09 19:13:00 +08:00
|
|
|
default:
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-23 21:23:01 +08:00
|
|
|
static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *keys;
|
|
|
|
|
uint64_t hva;
|
2017-07-10 19:35:48 +08:00
|
|
|
int srcu_idx, i, r = 0;
|
2014-09-23 21:23:01 +08:00
|
|
|
|
|
|
|
|
if (args->flags != 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Is this guest using storage keys? */
|
2018-02-15 23:33:47 +08:00
|
|
|
if (!mm_uses_skeys(current->mm))
|
2014-09-23 21:23:01 +08:00
|
|
|
return KVM_S390_GET_SKEYS_NONE;
|
|
|
|
|
|
|
|
|
|
/* Enforce sane limit on memory allocation */
|
|
|
|
|
if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2017-05-09 06:57:27 +08:00
|
|
|
keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL);
|
2014-09-23 21:23:01 +08:00
|
|
|
if (!keys)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2016-03-08 18:53:35 +08:00
|
|
|
down_read(¤t->mm->mmap_sem);
|
2017-07-10 19:35:48 +08:00
|
|
|
srcu_idx = srcu_read_lock(&kvm->srcu);
|
2014-09-23 21:23:01 +08:00
|
|
|
for (i = 0; i < args->count; i++) {
|
|
|
|
|
hva = gfn_to_hva(kvm, args->start_gfn + i);
|
|
|
|
|
if (kvm_is_error_hva(hva)) {
|
|
|
|
|
r = -EFAULT;
|
2016-03-08 18:53:35 +08:00
|
|
|
break;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-09 17:22:34 +08:00
|
|
|
r = get_guest_storage_key(current->mm, hva, &keys[i]);
|
|
|
|
|
if (r)
|
2016-03-08 18:53:35 +08:00
|
|
|
break;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
2017-07-10 19:35:48 +08:00
|
|
|
srcu_read_unlock(&kvm->srcu, srcu_idx);
|
2016-03-08 18:53:35 +08:00
|
|
|
up_read(¤t->mm->mmap_sem);
|
|
|
|
|
|
|
|
|
|
if (!r) {
|
|
|
|
|
r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys,
|
|
|
|
|
sizeof(uint8_t) * args->count);
|
|
|
|
|
if (r)
|
|
|
|
|
r = -EFAULT;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kvfree(keys);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *keys;
|
|
|
|
|
uint64_t hva;
|
2017-07-10 19:35:48 +08:00
|
|
|
int srcu_idx, i, r = 0;
|
2018-07-18 20:40:22 +08:00
|
|
|
bool unlocked;
|
2014-09-23 21:23:01 +08:00
|
|
|
|
|
|
|
|
if (args->flags != 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Enforce sane limit on memory allocation */
|
|
|
|
|
if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2017-05-09 06:57:27 +08:00
|
|
|
keys = kvmalloc_array(args->count, sizeof(uint8_t), GFP_KERNEL);
|
2014-09-23 21:23:01 +08:00
|
|
|
if (!keys)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr,
|
|
|
|
|
sizeof(uint8_t) * args->count);
|
|
|
|
|
if (r) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Enable storage key handling for the guest */
|
2015-05-07 21:16:13 +08:00
|
|
|
r = s390_enable_skey();
|
|
|
|
|
if (r)
|
|
|
|
|
goto out;
|
2014-09-23 21:23:01 +08:00
|
|
|
|
2018-07-18 20:40:22 +08:00
|
|
|
i = 0;
|
2016-03-08 18:53:35 +08:00
|
|
|
down_read(¤t->mm->mmap_sem);
|
2017-07-10 19:35:48 +08:00
|
|
|
srcu_idx = srcu_read_lock(&kvm->srcu);
|
2018-07-18 20:40:22 +08:00
|
|
|
while (i < args->count) {
|
|
|
|
|
unlocked = false;
|
2014-09-23 21:23:01 +08:00
|
|
|
hva = gfn_to_hva(kvm, args->start_gfn + i);
|
|
|
|
|
if (kvm_is_error_hva(hva)) {
|
|
|
|
|
r = -EFAULT;
|
2016-03-08 18:53:35 +08:00
|
|
|
break;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Lowest order bit is reserved */
|
|
|
|
|
if (keys[i] & 0x01) {
|
|
|
|
|
r = -EINVAL;
|
2016-03-08 18:53:35 +08:00
|
|
|
break;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-09 19:08:07 +08:00
|
|
|
r = set_guest_storage_key(current->mm, hva, keys[i], 0);
|
2018-07-18 20:40:22 +08:00
|
|
|
if (r) {
|
|
|
|
|
r = fixup_user_fault(current, current->mm, hva,
|
|
|
|
|
FAULT_FLAG_WRITE, &unlocked);
|
|
|
|
|
if (r)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!r)
|
|
|
|
|
i++;
|
2014-09-23 21:23:01 +08:00
|
|
|
}
|
2017-07-10 19:35:48 +08:00
|
|
|
srcu_read_unlock(&kvm->srcu, srcu_idx);
|
2016-03-08 18:53:35 +08:00
|
|
|
up_read(¤t->mm->mmap_sem);
|
2014-09-23 21:23:01 +08:00
|
|
|
out:
|
|
|
|
|
kvfree(keys);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-04 23:58:47 +08:00
|
|
|
/*
|
|
|
|
|
* Base address and length must be sent at the start of each block, therefore
|
|
|
|
|
* it's cheaper to send some clean data, as long as it's less than the size of
|
|
|
|
|
* two longs.
|
|
|
|
|
*/
|
|
|
|
|
#define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *))
|
|
|
|
|
/* for consistency */
|
|
|
|
|
#define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX)
|
|
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
/*
|
|
|
|
|
* Similar to gfn_to_memslot, but returns the index of a memslot also when the
|
|
|
|
|
* address falls in a hole. In that case the index of one of the memslots
|
|
|
|
|
* bordering the hole is returned.
|
|
|
|
|
*/
|
|
|
|
|
static int gfn_to_memslot_approx(struct kvm_memslots *slots, gfn_t gfn)
|
|
|
|
|
{
|
|
|
|
|
int start = 0, end = slots->used_slots;
|
|
|
|
|
int slot = atomic_read(&slots->lru_slot);
|
|
|
|
|
struct kvm_memory_slot *memslots = slots->memslots;
|
|
|
|
|
|
|
|
|
|
if (gfn >= memslots[slot].base_gfn &&
|
|
|
|
|
gfn < memslots[slot].base_gfn + memslots[slot].npages)
|
|
|
|
|
return slot;
|
|
|
|
|
|
|
|
|
|
while (start < end) {
|
|
|
|
|
slot = start + (end - start) / 2;
|
|
|
|
|
|
|
|
|
|
if (gfn >= memslots[slot].base_gfn)
|
|
|
|
|
end = slot;
|
|
|
|
|
else
|
|
|
|
|
start = slot + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (gfn >= memslots[start].base_gfn &&
|
|
|
|
|
gfn < memslots[start].base_gfn + memslots[start].npages) {
|
|
|
|
|
atomic_set(&slots->lru_slot, start);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return start;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_peek_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args,
|
|
|
|
|
u8 *res, unsigned long bufsize)
|
|
|
|
|
{
|
|
|
|
|
unsigned long pgstev, hva, cur_gfn = args->start_gfn;
|
|
|
|
|
|
|
|
|
|
args->count = 0;
|
|
|
|
|
while (args->count < bufsize) {
|
|
|
|
|
hva = gfn_to_hva(kvm, cur_gfn);
|
|
|
|
|
/*
|
|
|
|
|
* We return an error if the first value was invalid, but we
|
|
|
|
|
* return successfully if at least one value was copied.
|
|
|
|
|
*/
|
|
|
|
|
if (kvm_is_error_hva(hva))
|
|
|
|
|
return args->count ? 0 : -EFAULT;
|
|
|
|
|
if (get_pgste(kvm->mm, hva, &pgstev) < 0)
|
|
|
|
|
pgstev = 0;
|
|
|
|
|
res[args->count++] = (pgstev >> 24) & 0x43;
|
|
|
|
|
cur_gfn++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long kvm_s390_next_dirty_cmma(struct kvm_memslots *slots,
|
|
|
|
|
unsigned long cur_gfn)
|
|
|
|
|
{
|
|
|
|
|
int slotidx = gfn_to_memslot_approx(slots, cur_gfn);
|
|
|
|
|
struct kvm_memory_slot *ms = slots->memslots + slotidx;
|
|
|
|
|
unsigned long ofs = cur_gfn - ms->base_gfn;
|
|
|
|
|
|
|
|
|
|
if (ms->base_gfn + ms->npages <= cur_gfn) {
|
|
|
|
|
slotidx--;
|
|
|
|
|
/* If we are above the highest slot, wrap around */
|
|
|
|
|
if (slotidx < 0)
|
|
|
|
|
slotidx = slots->used_slots - 1;
|
|
|
|
|
|
|
|
|
|
ms = slots->memslots + slotidx;
|
|
|
|
|
ofs = 0;
|
|
|
|
|
}
|
|
|
|
|
ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, ofs);
|
|
|
|
|
while ((slotidx > 0) && (ofs >= ms->npages)) {
|
|
|
|
|
slotidx--;
|
|
|
|
|
ms = slots->memslots + slotidx;
|
|
|
|
|
ofs = find_next_bit(kvm_second_dirty_bitmap(ms), ms->npages, 0);
|
|
|
|
|
}
|
|
|
|
|
return ms->base_gfn + ofs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_s390_get_cmma(struct kvm *kvm, struct kvm_s390_cmma_log *args,
|
|
|
|
|
u8 *res, unsigned long bufsize)
|
|
|
|
|
{
|
|
|
|
|
unsigned long mem_end, cur_gfn, next_gfn, hva, pgstev;
|
|
|
|
|
struct kvm_memslots *slots = kvm_memslots(kvm);
|
|
|
|
|
struct kvm_memory_slot *ms;
|
|
|
|
|
|
|
|
|
|
cur_gfn = kvm_s390_next_dirty_cmma(slots, args->start_gfn);
|
|
|
|
|
ms = gfn_to_memslot(kvm, cur_gfn);
|
|
|
|
|
args->count = 0;
|
|
|
|
|
args->start_gfn = cur_gfn;
|
|
|
|
|
if (!ms)
|
|
|
|
|
return 0;
|
|
|
|
|
next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1);
|
|
|
|
|
mem_end = slots->memslots[0].base_gfn + slots->memslots[0].npages;
|
|
|
|
|
|
|
|
|
|
while (args->count < bufsize) {
|
|
|
|
|
hva = gfn_to_hva(kvm, cur_gfn);
|
|
|
|
|
if (kvm_is_error_hva(hva))
|
|
|
|
|
return 0;
|
|
|
|
|
/* Decrement only if we actually flipped the bit to 0 */
|
|
|
|
|
if (test_and_clear_bit(cur_gfn - ms->base_gfn, kvm_second_dirty_bitmap(ms)))
|
|
|
|
|
atomic64_dec(&kvm->arch.cmma_dirty_pages);
|
|
|
|
|
if (get_pgste(kvm->mm, hva, &pgstev) < 0)
|
|
|
|
|
pgstev = 0;
|
|
|
|
|
/* Save the value */
|
|
|
|
|
res[args->count++] = (pgstev >> 24) & 0x43;
|
|
|
|
|
/* If the next bit is too far away, stop. */
|
|
|
|
|
if (next_gfn > cur_gfn + KVM_S390_MAX_BIT_DISTANCE)
|
|
|
|
|
return 0;
|
|
|
|
|
/* If we reached the previous "next", find the next one */
|
|
|
|
|
if (cur_gfn == next_gfn)
|
|
|
|
|
next_gfn = kvm_s390_next_dirty_cmma(slots, cur_gfn + 1);
|
|
|
|
|
/* Reached the end of memory or of the buffer, stop */
|
|
|
|
|
if ((next_gfn >= mem_end) ||
|
|
|
|
|
(next_gfn - args->start_gfn >= bufsize))
|
|
|
|
|
return 0;
|
|
|
|
|
cur_gfn++;
|
|
|
|
|
/* Reached the end of the current memslot, take the next one. */
|
|
|
|
|
if (cur_gfn - ms->base_gfn >= ms->npages) {
|
|
|
|
|
ms = gfn_to_memslot(kvm, cur_gfn);
|
|
|
|
|
if (!ms)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-04 23:58:47 +08:00
|
|
|
/*
|
|
|
|
|
* This function searches for the next page with dirty CMMA attributes, and
|
|
|
|
|
* saves the attributes in the buffer up to either the end of the buffer or
|
|
|
|
|
* until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found;
|
|
|
|
|
* no trailing clean bytes are saved.
|
|
|
|
|
* In case no dirty bits were found, or if CMMA was not enabled or used, the
|
|
|
|
|
* output buffer will indicate 0 as length.
|
|
|
|
|
*/
|
|
|
|
|
static int kvm_s390_get_cmma_bits(struct kvm *kvm,
|
|
|
|
|
struct kvm_s390_cmma_log *args)
|
|
|
|
|
{
|
2018-05-01 00:33:25 +08:00
|
|
|
unsigned long bufsize;
|
|
|
|
|
int srcu_idx, peek, ret;
|
|
|
|
|
u8 *values;
|
2016-08-04 23:58:47 +08:00
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
if (!kvm->arch.use_cmma)
|
2016-08-04 23:58:47 +08:00
|
|
|
return -ENXIO;
|
|
|
|
|
/* Invalid/unsupported flags were specified */
|
|
|
|
|
if (args->flags & ~KVM_S390_CMMA_PEEK)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
/* Migration mode query, and we are not doing a migration */
|
|
|
|
|
peek = !!(args->flags & KVM_S390_CMMA_PEEK);
|
2018-05-01 00:33:25 +08:00
|
|
|
if (!peek && !kvm->arch.migration_mode)
|
2016-08-04 23:58:47 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
/* CMMA is disabled or was not used, or the buffer has length zero */
|
|
|
|
|
bufsize = min(args->count, KVM_S390_CMMA_SIZE_MAX);
|
2018-02-16 19:16:14 +08:00
|
|
|
if (!bufsize || !kvm->mm->context.uses_cmm) {
|
2016-08-04 23:58:47 +08:00
|
|
|
memset(args, 0, sizeof(*args));
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2018-05-01 00:33:25 +08:00
|
|
|
/* We are not peeking, and there are no dirty pages */
|
|
|
|
|
if (!peek && !atomic64_read(&kvm->arch.cmma_dirty_pages)) {
|
|
|
|
|
memset(args, 0, sizeof(*args));
|
|
|
|
|
return 0;
|
2016-08-04 23:58:47 +08:00
|
|
|
}
|
|
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
values = vmalloc(bufsize);
|
|
|
|
|
if (!values)
|
2016-08-04 23:58:47 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
down_read(&kvm->mm->mmap_sem);
|
|
|
|
|
srcu_idx = srcu_read_lock(&kvm->srcu);
|
2018-05-01 00:33:25 +08:00
|
|
|
if (peek)
|
|
|
|
|
ret = kvm_s390_peek_cmma(kvm, args, values, bufsize);
|
|
|
|
|
else
|
|
|
|
|
ret = kvm_s390_get_cmma(kvm, args, values, bufsize);
|
2016-08-04 23:58:47 +08:00
|
|
|
srcu_read_unlock(&kvm->srcu, srcu_idx);
|
|
|
|
|
up_read(&kvm->mm->mmap_sem);
|
|
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
if (kvm->arch.migration_mode)
|
|
|
|
|
args->remaining = atomic64_read(&kvm->arch.cmma_dirty_pages);
|
|
|
|
|
else
|
|
|
|
|
args->remaining = 0;
|
2016-08-04 23:58:47 +08:00
|
|
|
|
2018-05-01 00:33:25 +08:00
|
|
|
if (copy_to_user((void __user *)args->values, values, args->count))
|
|
|
|
|
ret = -EFAULT;
|
|
|
|
|
|
|
|
|
|
vfree(values);
|
|
|
|
|
return ret;
|
2016-08-04 23:58:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This function sets the CMMA attributes for the given pages. If the input
|
|
|
|
|
* buffer has zero length, no action is taken, otherwise the attributes are
|
2018-02-16 19:16:14 +08:00
|
|
|
* set and the mm->context.uses_cmm flag is set.
|
2016-08-04 23:58:47 +08:00
|
|
|
*/
|
|
|
|
|
static int kvm_s390_set_cmma_bits(struct kvm *kvm,
|
|
|
|
|
const struct kvm_s390_cmma_log *args)
|
|
|
|
|
{
|
|
|
|
|
unsigned long hva, mask, pgstev, i;
|
|
|
|
|
uint8_t *bits;
|
|
|
|
|
int srcu_idx, r = 0;
|
|
|
|
|
|
|
|
|
|
mask = args->mask;
|
|
|
|
|
|
|
|
|
|
if (!kvm->arch.use_cmma)
|
|
|
|
|
return -ENXIO;
|
|
|
|
|
/* invalid/unsupported flags */
|
|
|
|
|
if (args->flags != 0)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
/* Enforce sane limit on memory allocation */
|
|
|
|
|
if (args->count > KVM_S390_CMMA_SIZE_MAX)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
/* Nothing to do */
|
|
|
|
|
if (args->count == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
treewide: Use array_size() in vmalloc()
The vmalloc() function has no 2-factor argument form, so multiplication
factors need to be wrapped in array_size(). This patch replaces cases of:
vmalloc(a * b)
with:
vmalloc(array_size(a, b))
as well as handling cases of:
vmalloc(a * b * c)
with:
vmalloc(array3_size(a, b, c))
This does, however, attempt to ignore constant size factors like:
vmalloc(4 * 1024)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
vmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
vmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
vmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_ID
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_ID
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
vmalloc(
- SIZE * COUNT
+ array_size(COUNT, SIZE)
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
vmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
vmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
vmalloc(C1 * C2 * C3, ...)
|
vmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants.
@@
expression E1, E2;
constant C1, C2;
@@
(
vmalloc(C1 * C2, ...)
|
vmalloc(
- E1 * E2
+ array_size(E1, E2)
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 05:27:11 +08:00
|
|
|
bits = vmalloc(array_size(sizeof(*bits), args->count));
|
2016-08-04 23:58:47 +08:00
|
|
|
if (!bits)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
r = copy_from_user(bits, (void __user *)args->values, args->count);
|
|
|
|
|
if (r) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
down_read(&kvm->mm->mmap_sem);
|
|
|
|
|
srcu_idx = srcu_read_lock(&kvm->srcu);
|
|
|
|
|
for (i = 0; i < args->count; i++) {
|
|
|
|
|
hva = gfn_to_hva(kvm, args->start_gfn + i);
|
|
|
|
|
if (kvm_is_error_hva(hva)) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pgstev = bits[i];
|
|
|
|
|
pgstev = pgstev << 24;
|
2016-08-29 21:56:55 +08:00
|
|
|
mask &= _PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT;
|
2016-08-04 23:58:47 +08:00
|
|
|
set_pgste_bits(kvm->mm, hva, mask, pgstev);
|
|
|
|
|
}
|
|
|
|
|
srcu_read_unlock(&kvm->srcu, srcu_idx);
|
|
|
|
|
up_read(&kvm->mm->mmap_sem);
|
|
|
|
|
|
2018-02-16 19:16:14 +08:00
|
|
|
if (!kvm->mm->context.uses_cmm) {
|
2016-08-04 23:58:47 +08:00
|
|
|
down_write(&kvm->mm->mmap_sem);
|
2018-02-16 19:16:14 +08:00
|
|
|
kvm->mm->context.uses_cmm = 1;
|
2016-08-04 23:58:47 +08:00
|
|
|
up_write(&kvm->mm->mmap_sem);
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
vfree(bits);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
long kvm_arch_vm_ioctl(struct file *filp,
|
|
|
|
|
unsigned int ioctl, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
struct kvm *kvm = filp->private_data;
|
|
|
|
|
void __user *argp = (void __user *)arg;
|
2014-04-09 19:13:00 +08:00
|
|
|
struct kvm_device_attr attr;
|
2008-03-26 01:47:20 +08:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
switch (ioctl) {
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
case KVM_S390_INTERRUPT: {
|
|
|
|
|
struct kvm_s390_interrupt s390int;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&s390int, argp, sizeof(s390int)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_inject_vm(kvm, &s390int);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-07-15 19:36:01 +08:00
|
|
|
case KVM_CREATE_IRQCHIP: {
|
|
|
|
|
struct kvm_irq_routing_entry routing;
|
|
|
|
|
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
if (kvm->arch.use_irqchip) {
|
|
|
|
|
/* Set up dummy routing. */
|
|
|
|
|
memset(&routing, 0, sizeof(routing));
|
2015-08-07 01:05:54 +08:00
|
|
|
r = kvm_set_irq_routing(kvm, &routing, 0, 0);
|
2013-07-15 19:36:01 +08:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-04-09 19:13:00 +08:00
|
|
|
case KVM_SET_DEVICE_ATTR: {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_vm_set_attr(kvm, &attr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_GET_DEVICE_ATTR: {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_vm_get_attr(kvm, &attr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_HAS_DEVICE_ATTR: {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_vm_has_attr(kvm, &attr);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-09-23 21:23:01 +08:00
|
|
|
case KVM_S390_GET_SKEYS: {
|
|
|
|
|
struct kvm_s390_skeys args;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&args, argp,
|
|
|
|
|
sizeof(struct kvm_s390_skeys)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_get_skeys(kvm, &args);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_S390_SET_SKEYS: {
|
|
|
|
|
struct kvm_s390_skeys args;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&args, argp,
|
|
|
|
|
sizeof(struct kvm_s390_skeys)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_s390_set_skeys(kvm, &args);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2016-08-04 23:58:47 +08:00
|
|
|
case KVM_S390_GET_CMMA_BITS: {
|
|
|
|
|
struct kvm_s390_cmma_log args;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&args, argp, sizeof(args)))
|
|
|
|
|
break;
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_lock(&kvm->slots_lock);
|
2016-08-04 23:58:47 +08:00
|
|
|
r = kvm_s390_get_cmma_bits(kvm, &args);
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_unlock(&kvm->slots_lock);
|
2016-08-04 23:58:47 +08:00
|
|
|
if (!r) {
|
|
|
|
|
r = copy_to_user(argp, &args, sizeof(args));
|
|
|
|
|
if (r)
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_S390_SET_CMMA_BITS: {
|
|
|
|
|
struct kvm_s390_cmma_log args;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&args, argp, sizeof(args)))
|
|
|
|
|
break;
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_lock(&kvm->slots_lock);
|
2016-08-04 23:58:47 +08:00
|
|
|
r = kvm_s390_set_cmma_bits(kvm, &args);
|
2017-12-22 17:54:20 +08:00
|
|
|
mutex_unlock(&kvm->slots_lock);
|
2016-08-04 23:58:47 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2008-03-26 01:47:20 +08:00
|
|
|
default:
|
2009-08-26 19:57:07 +08:00
|
|
|
r = -ENOTTY;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-14 00:33:26 +08:00
|
|
|
static int kvm_s390_apxa_installed(void)
|
|
|
|
|
{
|
2018-09-26 07:16:18 +08:00
|
|
|
struct ap_config_info info;
|
2015-01-14 00:33:26 +08:00
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
if (ap_instructions_available()) {
|
|
|
|
|
if (ap_qci(&info) == 0)
|
|
|
|
|
return info.apxa;
|
2015-01-14 00:33:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
/*
|
|
|
|
|
* The format of the crypto control block (CRYCB) is specified in the 3 low
|
|
|
|
|
* order bits of the CRYCB designation (CRYCBD) field as follows:
|
|
|
|
|
* Format 0: Neither the message security assist extension 3 (MSAX3) nor the
|
|
|
|
|
* AP extended addressing (APXA) facility are installed.
|
|
|
|
|
* Format 1: The APXA facility is not installed but the MSAX3 facility is.
|
|
|
|
|
* Format 2: Both the APXA and MSAX3 facilities are installed
|
|
|
|
|
*/
|
2015-01-14 00:33:26 +08:00
|
|
|
static void kvm_s390_set_crycb_format(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb;
|
|
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
/* Clear the CRYCB format bits - i.e., set format 0 by default */
|
|
|
|
|
kvm->arch.crypto.crycbd &= ~(CRYCB_FORMAT_MASK);
|
|
|
|
|
|
|
|
|
|
/* Check whether MSAX3 is installed */
|
|
|
|
|
if (!test_kvm_facility(kvm, 76))
|
|
|
|
|
return;
|
|
|
|
|
|
2015-01-14 00:33:26 +08:00
|
|
|
if (kvm_s390_apxa_installed())
|
|
|
|
|
kvm->arch.crypto.crycbd |= CRYCB_FORMAT2;
|
|
|
|
|
else
|
|
|
|
|
kvm->arch.crypto.crycbd |= CRYCB_FORMAT1;
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-05 16:31:09 +08:00
|
|
|
void kvm_arch_crypto_set_masks(struct kvm *kvm, unsigned long *apm,
|
|
|
|
|
unsigned long *aqm, unsigned long *adm)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_crypto_cb *crycb = kvm->arch.crypto.crycb;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
kvm_s390_vcpu_block_all(kvm);
|
|
|
|
|
|
|
|
|
|
switch (kvm->arch.crypto.crycbd & CRYCB_FORMAT_MASK) {
|
|
|
|
|
case CRYCB_FORMAT2: /* APCB1 use 256 bits */
|
|
|
|
|
memcpy(crycb->apcb1.apm, apm, 32);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx %016lx %016lx %016lx",
|
|
|
|
|
apm[0], apm[1], apm[2], apm[3]);
|
|
|
|
|
memcpy(crycb->apcb1.aqm, aqm, 32);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET CRYCB: aqm %016lx %016lx %016lx %016lx",
|
|
|
|
|
aqm[0], aqm[1], aqm[2], aqm[3]);
|
|
|
|
|
memcpy(crycb->apcb1.adm, adm, 32);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET CRYCB: adm %016lx %016lx %016lx %016lx",
|
|
|
|
|
adm[0], adm[1], adm[2], adm[3]);
|
|
|
|
|
break;
|
|
|
|
|
case CRYCB_FORMAT1:
|
|
|
|
|
case CRYCB_FORMAT0: /* Fall through both use APCB0 */
|
|
|
|
|
memcpy(crycb->apcb0.apm, apm, 8);
|
|
|
|
|
memcpy(crycb->apcb0.aqm, aqm, 2);
|
|
|
|
|
memcpy(crycb->apcb0.adm, adm, 2);
|
|
|
|
|
VM_EVENT(kvm, 3, "SET CRYCB: apm %016lx aqm %04x adm %04x",
|
|
|
|
|
apm[0], *((unsigned short *)aqm),
|
|
|
|
|
*((unsigned short *)adm));
|
|
|
|
|
break;
|
|
|
|
|
default: /* Can not happen */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* recreate the shadow crycb for each vcpu */
|
|
|
|
|
kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART);
|
|
|
|
|
kvm_s390_vcpu_unblock_all(kvm);
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(kvm_arch_crypto_set_masks);
|
|
|
|
|
|
2018-09-26 07:16:25 +08:00
|
|
|
void kvm_arch_crypto_clear_masks(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
kvm_s390_vcpu_block_all(kvm);
|
|
|
|
|
|
|
|
|
|
memset(&kvm->arch.crypto.crycb->apcb0, 0,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->apcb0));
|
|
|
|
|
memset(&kvm->arch.crypto.crycb->apcb1, 0,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->apcb1));
|
|
|
|
|
|
2018-10-05 16:31:09 +08:00
|
|
|
VM_EVENT(kvm, 3, "%s", "CLR CRYCB:");
|
2018-09-26 07:16:30 +08:00
|
|
|
/* recreate the shadow crycb for each vcpu */
|
|
|
|
|
kvm_s390_sync_request_broadcast(kvm, KVM_REQ_VSIE_RESTART);
|
2018-09-26 07:16:25 +08:00
|
|
|
kvm_s390_vcpu_unblock_all(kvm);
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(kvm_arch_crypto_clear_masks);
|
|
|
|
|
|
2016-04-04 20:27:51 +08:00
|
|
|
static u64 kvm_s390_get_initial_cpuid(void)
|
2015-02-02 22:42:51 +08:00
|
|
|
{
|
2016-04-04 20:27:51 +08:00
|
|
|
struct cpuid cpuid;
|
|
|
|
|
|
|
|
|
|
get_cpu_id(&cpuid);
|
|
|
|
|
cpuid.version = 0xff;
|
|
|
|
|
return *((u64 *) &cpuid);
|
2015-02-02 22:42:51 +08:00
|
|
|
}
|
|
|
|
|
|
2015-12-02 15:53:52 +08:00
|
|
|
static void kvm_s390_crypto_init(struct kvm *kvm)
|
2014-06-28 02:46:01 +08:00
|
|
|
{
|
2015-12-02 15:53:52 +08:00
|
|
|
kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb;
|
2015-01-14 00:33:26 +08:00
|
|
|
kvm_s390_set_crycb_format(kvm);
|
2014-06-28 02:46:01 +08:00
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
if (!test_kvm_facility(kvm, 76))
|
|
|
|
|
return;
|
|
|
|
|
|
2015-02-25 03:06:57 +08:00
|
|
|
/* Enable AES/DEA protected key functions by default */
|
|
|
|
|
kvm->arch.crypto.aes_kw = 1;
|
|
|
|
|
kvm->arch.crypto.dea_kw = 1;
|
|
|
|
|
get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
|
|
|
|
|
get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask,
|
|
|
|
|
sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
|
2014-06-28 02:46:01 +08:00
|
|
|
}
|
|
|
|
|
|
2015-04-22 23:09:44 +08:00
|
|
|
static void sca_dispose(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
if (kvm->arch.use_esca)
|
2015-04-23 00:08:39 +08:00
|
|
|
free_pages_exact(kvm->arch.sca, sizeof(struct esca_block));
|
2015-04-22 23:09:44 +08:00
|
|
|
else
|
|
|
|
|
free_page((unsigned long)(kvm->arch.sca));
|
|
|
|
|
kvm->arch.sca = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-04 17:25:20 +08:00
|
|
|
int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2015-11-24 20:33:49 +08:00
|
|
|
gfp_t alloc_flags = GFP_KERNEL;
|
2015-02-02 22:42:51 +08:00
|
|
|
int i, rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
char debug_name[16];
|
2014-03-19 18:18:29 +08:00
|
|
|
static unsigned long sca_offset;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2012-01-04 17:25:20 +08:00
|
|
|
rc = -EINVAL;
|
|
|
|
|
#ifdef CONFIG_KVM_S390_UCONTROL
|
|
|
|
|
if (type & ~KVM_VM_S390_UCONTROL)
|
|
|
|
|
goto out_err;
|
|
|
|
|
if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
|
|
|
|
|
goto out_err;
|
|
|
|
|
#else
|
|
|
|
|
if (type)
|
|
|
|
|
goto out_err;
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
rc = s390_enable_sie();
|
|
|
|
|
if (rc)
|
2010-11-10 00:02:49 +08:00
|
|
|
goto out_err;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2011-10-18 18:27:13 +08:00
|
|
|
rc = -ENOMEM;
|
|
|
|
|
|
2015-11-24 20:33:49 +08:00
|
|
|
if (!sclp.has_64bscao)
|
|
|
|
|
alloc_flags |= GFP_DMA;
|
2015-04-23 00:08:39 +08:00
|
|
|
rwlock_init(&kvm->arch.sca_lock);
|
2018-04-27 20:36:12 +08:00
|
|
|
/* start with basic SCA */
|
2015-11-24 20:33:49 +08:00
|
|
|
kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags);
|
2008-03-26 01:47:20 +08:00
|
|
|
if (!kvm->arch.sca)
|
2010-11-10 00:02:49 +08:00
|
|
|
goto out_err;
|
2014-03-19 18:18:29 +08:00
|
|
|
spin_lock(&kvm_lock);
|
2015-10-26 15:41:29 +08:00
|
|
|
sca_offset += 16;
|
2015-04-23 22:09:06 +08:00
|
|
|
if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE)
|
2015-10-26 15:41:29 +08:00
|
|
|
sca_offset = 0;
|
2015-04-23 22:09:06 +08:00
|
|
|
kvm->arch.sca = (struct bsca_block *)
|
|
|
|
|
((char *) kvm->arch.sca + sca_offset);
|
2014-03-19 18:18:29 +08:00
|
|
|
spin_unlock(&kvm_lock);
|
2008-03-26 01:47:20 +08:00
|
|
|
|
|
|
|
|
sprintf(debug_name, "kvm-%u", current->pid);
|
|
|
|
|
|
2015-07-20 21:04:48 +08:00
|
|
|
kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long));
|
2008-03-26 01:47:20 +08:00
|
|
|
if (!kvm->arch.dbf)
|
2015-03-12 20:55:53 +08:00
|
|
|
goto out_err;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2017-05-30 20:26:02 +08:00
|
|
|
BUILD_BUG_ON(sizeof(struct sie_page2) != 4096);
|
2015-12-02 15:53:52 +08:00
|
|
|
kvm->arch.sie_page2 =
|
|
|
|
|
(struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
|
|
|
|
|
if (!kvm->arch.sie_page2)
|
2015-03-12 20:55:53 +08:00
|
|
|
goto out_err;
|
2015-02-02 22:42:51 +08:00
|
|
|
|
2019-01-31 16:52:41 +08:00
|
|
|
kvm->arch.sie_page2->kvm = kvm;
|
2015-12-02 15:53:52 +08:00
|
|
|
kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list;
|
2018-02-10 00:26:29 +08:00
|
|
|
|
|
|
|
|
for (i = 0; i < kvm_s390_fac_size(); i++) {
|
|
|
|
|
kvm->arch.model.fac_mask[i] = S390_lowcore.stfle_fac_list[i] &
|
|
|
|
|
(kvm_s390_fac_base[i] |
|
|
|
|
|
kvm_s390_fac_ext[i]);
|
|
|
|
|
kvm->arch.model.fac_list[i] = S390_lowcore.stfle_fac_list[i] &
|
|
|
|
|
kvm_s390_fac_base[i];
|
|
|
|
|
}
|
2019-02-18 20:48:25 +08:00
|
|
|
kvm->arch.model.subfuncs = kvm_s390_available_subfunc;
|
2015-02-24 20:51:04 +08:00
|
|
|
|
2017-08-29 22:31:08 +08:00
|
|
|
/* we are always in czam mode - even on pre z14 machines */
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 138);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 138);
|
|
|
|
|
/* we emulate STHYI in kvm */
|
2016-05-23 21:11:58 +08:00
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 74);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 74);
|
2016-08-29 21:56:55 +08:00
|
|
|
if (MACHINE_HAS_TLB_GUEST) {
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_mask, 147);
|
|
|
|
|
set_kvm_facility(kvm->arch.model.fac_list, 147);
|
|
|
|
|
}
|
2016-05-23 21:11:58 +08:00
|
|
|
|
2016-04-04 20:27:51 +08:00
|
|
|
kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid();
|
2015-05-06 19:18:59 +08:00
|
|
|
kvm->arch.model.ibc = sclp.ibc & 0x0fff;
|
2015-02-02 22:42:51 +08:00
|
|
|
|
2015-12-02 15:53:52 +08:00
|
|
|
kvm_s390_crypto_init(kvm);
|
2014-06-28 02:46:01 +08:00
|
|
|
|
2017-02-17 17:06:26 +08:00
|
|
|
mutex_init(&kvm->arch.float_int.ais_lock);
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
spin_lock_init(&kvm->arch.float_int.lock);
|
2013-07-03 21:18:35 +08:00
|
|
|
for (i = 0; i < FIRQ_LIST_COUNT; i++)
|
|
|
|
|
INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]);
|
2014-01-10 21:33:28 +08:00
|
|
|
init_waitqueue_head(&kvm->arch.ipte_wq);
|
2014-10-01 20:48:42 +08:00
|
|
|
mutex_init(&kvm->arch.ipte_mutex);
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
|
2015-07-22 21:50:58 +08:00
|
|
|
VM_EVENT(kvm, 3, "vm created with type %lu", type);
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2012-01-04 17:25:20 +08:00
|
|
|
if (type & KVM_VM_S390_UCONTROL) {
|
|
|
|
|
kvm->arch.gmap = NULL;
|
2014-12-02 00:24:42 +08:00
|
|
|
kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT;
|
2012-01-04 17:25:20 +08:00
|
|
|
} else {
|
2014-12-02 00:24:42 +08:00
|
|
|
if (sclp.hamax == U64_MAX)
|
2017-04-20 20:43:51 +08:00
|
|
|
kvm->arch.mem_limit = TASK_SIZE_MAX;
|
2014-12-02 00:24:42 +08:00
|
|
|
else
|
2017-04-20 20:43:51 +08:00
|
|
|
kvm->arch.mem_limit = min_t(unsigned long, TASK_SIZE_MAX,
|
2014-12-02 00:24:42 +08:00
|
|
|
sclp.hamax + 1);
|
2016-03-08 18:55:04 +08:00
|
|
|
kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1);
|
2012-01-04 17:25:20 +08:00
|
|
|
if (!kvm->arch.gmap)
|
2015-03-12 20:55:53 +08:00
|
|
|
goto out_err;
|
2013-05-17 20:41:36 +08:00
|
|
|
kvm->arch.gmap->private = kvm;
|
2013-06-17 22:25:18 +08:00
|
|
|
kvm->arch.gmap->pfault_enabled = 0;
|
2012-01-04 17:25:20 +08:00
|
|
|
}
|
2012-12-20 22:32:12 +08:00
|
|
|
|
2018-02-16 19:16:14 +08:00
|
|
|
kvm->arch.use_pfmfi = sclp.has_pfmfi;
|
2018-02-15 23:33:47 +08:00
|
|
|
kvm->arch.use_skf = sclp.has_skey;
|
2014-03-14 18:00:21 +08:00
|
|
|
spin_lock_init(&kvm->arch.start_stop_lock);
|
2015-07-08 19:19:48 +08:00
|
|
|
kvm_s390_vsie_init(kvm);
|
2017-06-12 20:15:19 +08:00
|
|
|
kvm_s390_gisa_init(kvm);
|
2015-12-08 23:55:27 +08:00
|
|
|
KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid);
|
2014-03-14 18:00:21 +08:00
|
|
|
|
2010-11-10 00:02:49 +08:00
|
|
|
return 0;
|
2015-03-12 20:55:53 +08:00
|
|
|
out_err:
|
2015-12-02 15:53:52 +08:00
|
|
|
free_page((unsigned long)kvm->arch.sie_page2);
|
2011-07-24 16:48:21 +08:00
|
|
|
debug_unregister(kvm->arch.dbf);
|
2015-04-22 23:09:44 +08:00
|
|
|
sca_dispose(kvm);
|
2015-07-22 21:50:58 +08:00
|
|
|
KVM_EVENT(3, "creation of vm failed: %d", rc);
|
2010-11-10 00:02:49 +08:00
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2016-09-08 02:47:23 +08:00
|
|
|
bool kvm_arch_has_vcpu_debugfs(void)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-26 21:50:27 +08:00
|
|
|
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
VCPU_EVENT(vcpu, 3, "%s", "free cpu");
|
2012-07-23 23:20:30 +08:00
|
|
|
trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
|
2014-03-26 00:09:08 +08:00
|
|
|
kvm_s390_clear_local_irqs(vcpu);
|
2013-10-07 23:11:48 +08:00
|
|
|
kvm_clear_async_pf_completion_queue(vcpu);
|
2015-04-23 22:09:06 +08:00
|
|
|
if (!kvm_is_ucontrol(vcpu->kvm))
|
2015-04-21 21:31:59 +08:00
|
|
|
sca_del_vcpu(vcpu);
|
2012-01-04 17:25:21 +08:00
|
|
|
|
|
|
|
|
if (kvm_is_ucontrol(vcpu->kvm))
|
2016-03-08 18:55:04 +08:00
|
|
|
gmap_remove(vcpu->arch.gmap);
|
2012-01-04 17:25:21 +08:00
|
|
|
|
2015-05-07 21:41:57 +08:00
|
|
|
if (vcpu->kvm->arch.use_cmma)
|
2014-03-25 20:47:11 +08:00
|
|
|
kvm_s390_vcpu_unsetup_cmma(vcpu);
|
2008-11-26 21:50:27 +08:00
|
|
|
free_page((unsigned long)(vcpu->arch.sie_block));
|
2013-04-17 23:36:29 +08:00
|
|
|
|
2008-11-26 21:51:08 +08:00
|
|
|
kvm_vcpu_uninit(vcpu);
|
2013-06-12 19:54:54 +08:00
|
|
|
kmem_cache_free(kvm_vcpu_cache, vcpu);
|
2008-11-26 21:50:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvm_free_vcpus(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
2009-06-09 20:56:29 +08:00
|
|
|
struct kvm_vcpu *vcpu;
|
2008-11-26 21:50:27 +08:00
|
|
|
|
2009-06-09 20:56:29 +08:00
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm)
|
|
|
|
|
kvm_arch_vcpu_destroy(vcpu);
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
|
|
|
|
|
kvm->vcpus[i] = NULL;
|
|
|
|
|
|
|
|
|
|
atomic_set(&kvm->online_vcpus, 0);
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
2008-11-26 21:50:27 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
void kvm_arch_destroy_vm(struct kvm *kvm)
|
|
|
|
|
{
|
2008-11-26 21:50:27 +08:00
|
|
|
kvm_free_vcpus(kvm);
|
2015-04-22 23:09:44 +08:00
|
|
|
sca_dispose(kvm);
|
2008-11-26 21:50:27 +08:00
|
|
|
debug_unregister(kvm->arch.dbf);
|
2017-06-12 20:15:19 +08:00
|
|
|
kvm_s390_gisa_destroy(kvm);
|
2015-12-02 15:53:52 +08:00
|
|
|
free_page((unsigned long)kvm->arch.sie_page2);
|
2012-01-04 17:25:21 +08:00
|
|
|
if (!kvm_is_ucontrol(kvm))
|
2016-03-08 18:55:04 +08:00
|
|
|
gmap_remove(kvm->arch.gmap);
|
2013-07-15 19:36:01 +08:00
|
|
|
kvm_s390_destroy_adapters(kvm);
|
2014-03-26 00:09:08 +08:00
|
|
|
kvm_s390_clear_float_irqs(kvm);
|
2015-07-08 19:19:48 +08:00
|
|
|
kvm_s390_vsie_destroy(kvm);
|
2015-12-08 23:55:27 +08:00
|
|
|
KVM_EVENT(3, "vm 0x%pK destroyed", kvm);
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Section: vcpu related */
|
2014-12-02 23:53:21 +08:00
|
|
|
static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-03-08 18:55:04 +08:00
|
|
|
vcpu->arch.gmap = gmap_create(current->mm, -1UL);
|
2014-12-02 23:53:21 +08:00
|
|
|
if (!vcpu->arch.gmap)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
vcpu->arch.gmap->private = vcpu->kvm;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-21 21:31:59 +08:00
|
|
|
static void sca_del_vcpu(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-08-09 04:39:32 +08:00
|
|
|
if (!kvm_s390_use_sca_entries())
|
|
|
|
|
return;
|
2015-04-23 00:08:39 +08:00
|
|
|
read_lock(&vcpu->kvm->arch.sca_lock);
|
2015-04-22 23:09:44 +08:00
|
|
|
if (vcpu->kvm->arch.use_esca) {
|
|
|
|
|
struct esca_block *sca = vcpu->kvm->arch.sca;
|
2015-04-21 21:31:59 +08:00
|
|
|
|
2015-04-22 23:09:44 +08:00
|
|
|
clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn);
|
2015-10-12 18:41:41 +08:00
|
|
|
sca->cpu[vcpu->vcpu_id].sda = 0;
|
2015-04-22 23:09:44 +08:00
|
|
|
} else {
|
|
|
|
|
struct bsca_block *sca = vcpu->kvm->arch.sca;
|
|
|
|
|
|
|
|
|
|
clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn);
|
2015-10-12 18:41:41 +08:00
|
|
|
sca->cpu[vcpu->vcpu_id].sda = 0;
|
2015-04-22 23:09:44 +08:00
|
|
|
}
|
2015-04-23 00:08:39 +08:00
|
|
|
read_unlock(&vcpu->kvm->arch.sca_lock);
|
2015-04-21 21:31:59 +08:00
|
|
|
}
|
|
|
|
|
|
2015-10-12 22:29:01 +08:00
|
|
|
static void sca_add_vcpu(struct kvm_vcpu *vcpu)
|
2015-04-21 21:31:59 +08:00
|
|
|
{
|
2016-08-09 04:39:32 +08:00
|
|
|
if (!kvm_s390_use_sca_entries()) {
|
|
|
|
|
struct bsca_block *sca = vcpu->kvm->arch.sca;
|
|
|
|
|
|
|
|
|
|
/* we still need the basic sca for the ipte control */
|
|
|
|
|
vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
|
|
|
|
|
vcpu->arch.sie_block->scaol = (__u32)(__u64)sca;
|
2018-03-06 21:27:58 +08:00
|
|
|
return;
|
2016-08-09 04:39:32 +08:00
|
|
|
}
|
2015-10-12 22:29:01 +08:00
|
|
|
read_lock(&vcpu->kvm->arch.sca_lock);
|
|
|
|
|
if (vcpu->kvm->arch.use_esca) {
|
|
|
|
|
struct esca_block *sca = vcpu->kvm->arch.sca;
|
2015-04-22 23:09:44 +08:00
|
|
|
|
2015-10-12 22:29:01 +08:00
|
|
|
sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block;
|
2015-04-22 23:09:44 +08:00
|
|
|
vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
|
|
|
|
|
vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU;
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb2 |= ECB2_ESCA;
|
2015-10-12 22:29:01 +08:00
|
|
|
set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn);
|
2015-04-22 23:09:44 +08:00
|
|
|
} else {
|
2015-10-12 22:29:01 +08:00
|
|
|
struct bsca_block *sca = vcpu->kvm->arch.sca;
|
2015-04-21 21:31:59 +08:00
|
|
|
|
2015-10-12 22:29:01 +08:00
|
|
|
sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block;
|
2015-04-22 23:09:44 +08:00
|
|
|
vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
|
|
|
|
|
vcpu->arch.sie_block->scaol = (__u32)(__u64)sca;
|
2015-10-12 22:29:01 +08:00
|
|
|
set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn);
|
2015-04-22 23:09:44 +08:00
|
|
|
}
|
2015-10-12 22:29:01 +08:00
|
|
|
read_unlock(&vcpu->kvm->arch.sca_lock);
|
2015-04-23 00:08:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Basic SCA to Extended SCA data copy routines */
|
|
|
|
|
static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s)
|
|
|
|
|
{
|
|
|
|
|
d->sda = s->sda;
|
|
|
|
|
d->sigp_ctrl.c = s->sigp_ctrl.c;
|
|
|
|
|
d->sigp_ctrl.scn = s->sigp_ctrl.scn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
d->ipte_control = s->ipte_control;
|
|
|
|
|
d->mcn[0] = s->mcn;
|
|
|
|
|
for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++)
|
|
|
|
|
sca_copy_entry(&d->cpu[i], &s->cpu[i]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sca_switch_to_extended(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
struct bsca_block *old_sca = kvm->arch.sca;
|
|
|
|
|
struct esca_block *new_sca;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
unsigned int vcpu_idx;
|
|
|
|
|
u32 scaol, scaoh;
|
|
|
|
|
|
|
|
|
|
new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO);
|
|
|
|
|
if (!new_sca)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
scaoh = (u32)((u64)(new_sca) >> 32);
|
|
|
|
|
scaol = (u32)(u64)(new_sca) & ~0x3fU;
|
|
|
|
|
|
|
|
|
|
kvm_s390_vcpu_block_all(kvm);
|
|
|
|
|
write_lock(&kvm->arch.sca_lock);
|
|
|
|
|
|
|
|
|
|
sca_copy_b_to_e(new_sca, old_sca);
|
|
|
|
|
|
|
|
|
|
kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) {
|
|
|
|
|
vcpu->arch.sie_block->scaoh = scaoh;
|
|
|
|
|
vcpu->arch.sie_block->scaol = scaol;
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb2 |= ECB2_ESCA;
|
2015-04-23 00:08:39 +08:00
|
|
|
}
|
|
|
|
|
kvm->arch.sca = new_sca;
|
|
|
|
|
kvm->arch.use_esca = 1;
|
|
|
|
|
|
|
|
|
|
write_unlock(&kvm->arch.sca_lock);
|
|
|
|
|
kvm_s390_vcpu_unblock_all(kvm);
|
|
|
|
|
|
|
|
|
|
free_page((unsigned long)old_sca);
|
|
|
|
|
|
2015-12-08 23:55:27 +08:00
|
|
|
VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)",
|
|
|
|
|
old_sca, kvm->arch.sca);
|
2015-04-23 00:08:39 +08:00
|
|
|
return 0;
|
2015-04-21 21:31:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id)
|
|
|
|
|
{
|
2015-04-23 00:08:39 +08:00
|
|
|
int rc;
|
|
|
|
|
|
2016-08-09 04:39:32 +08:00
|
|
|
if (!kvm_s390_use_sca_entries()) {
|
|
|
|
|
if (id < KVM_MAX_VCPUS)
|
|
|
|
|
return true;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2015-04-23 00:08:39 +08:00
|
|
|
if (id < KVM_S390_BSCA_CPU_SLOTS)
|
|
|
|
|
return true;
|
2015-11-24 20:33:49 +08:00
|
|
|
if (!sclp.has_esca || !sclp.has_64bscao)
|
2015-04-23 00:08:39 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm);
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
|
|
|
|
|
return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS;
|
2015-04-21 21:31:59 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2013-10-07 23:11:48 +08:00
|
|
|
vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
|
|
|
|
|
kvm_clear_async_pf_completion_queue(vcpu);
|
2012-01-11 18:20:33 +08:00
|
|
|
vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
|
|
|
|
|
KVM_SYNC_GPRS |
|
2012-02-06 17:59:07 +08:00
|
|
|
KVM_SYNC_ACRS |
|
2014-07-17 16:47:43 +08:00
|
|
|
KVM_SYNC_CRS |
|
|
|
|
|
KVM_SYNC_ARCH0 |
|
|
|
|
|
KVM_SYNC_PFAULT;
|
2016-08-03 22:39:54 +08:00
|
|
|
kvm_s390_set_prefix(vcpu, 0);
|
2016-01-07 18:24:29 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 64))
|
|
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB;
|
2018-01-17 21:44:34 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 82))
|
|
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC;
|
2016-11-29 14:17:55 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 133))
|
|
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB;
|
2018-03-09 00:08:49 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 156))
|
|
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_ETOKEN;
|
2016-01-15 21:11:46 +08:00
|
|
|
/* fprs can be synchronized via vrs, even if the guest has no vx. With
|
|
|
|
|
* MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format.
|
|
|
|
|
*/
|
|
|
|
|
if (MACHINE_HAS_VX)
|
2014-06-09 22:57:26 +08:00
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS;
|
2016-01-18 21:46:34 +08:00
|
|
|
else
|
|
|
|
|
vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS;
|
2014-12-02 23:53:21 +08:00
|
|
|
|
|
|
|
|
if (kvm_is_ucontrol(vcpu->kvm))
|
|
|
|
|
return __kvm_ucontrol_vcpu_init(vcpu);
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-15 16:42:25 +08:00
|
|
|
/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
|
|
|
|
|
static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(vcpu->arch.cputm_start != 0);
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
vcpu->arch.cputm_start = get_tod_clock_fast();
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
|
|
|
|
|
static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(vcpu->arch.cputm_start == 0);
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start;
|
|
|
|
|
vcpu->arch.cputm_start = 0;
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
|
|
|
|
|
static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(vcpu->arch.cputm_enabled);
|
|
|
|
|
vcpu->arch.cputm_enabled = true;
|
|
|
|
|
__start_cpu_timer_accounting(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
|
|
|
|
|
static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(!vcpu->arch.cputm_enabled);
|
|
|
|
|
__stop_cpu_timer_accounting(vcpu);
|
|
|
|
|
vcpu->arch.cputm_enabled = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
preempt_disable(); /* protect from TOD sync and vcpu_load/put */
|
|
|
|
|
__enable_cpu_timer_accounting(vcpu);
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
preempt_disable(); /* protect from TOD sync and vcpu_load/put */
|
|
|
|
|
__disable_cpu_timer_accounting(vcpu);
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-15 16:40:12 +08:00
|
|
|
/* set the cpu timer - may only be called from the VCPU thread itself */
|
|
|
|
|
void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm)
|
|
|
|
|
{
|
2016-02-15 16:42:25 +08:00
|
|
|
preempt_disable(); /* protect from TOD sync and vcpu_load/put */
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
if (vcpu->arch.cputm_enabled)
|
|
|
|
|
vcpu->arch.cputm_start = get_tod_clock_fast();
|
2016-02-15 16:40:12 +08:00
|
|
|
vcpu->arch.sie_block->cputm = cputm;
|
2016-02-18 04:53:33 +08:00
|
|
|
raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
|
2016-02-15 16:42:25 +08:00
|
|
|
preempt_enable();
|
2016-02-15 16:40:12 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-15 16:42:25 +08:00
|
|
|
/* update and get the cpu timer - can also be called from other VCPU threads */
|
2016-02-15 16:40:12 +08:00
|
|
|
__u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-02-18 04:53:33 +08:00
|
|
|
unsigned int seq;
|
2016-02-15 16:42:25 +08:00
|
|
|
__u64 value;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!vcpu->arch.cputm_enabled))
|
|
|
|
|
return vcpu->arch.sie_block->cputm;
|
|
|
|
|
|
2016-02-18 04:53:33 +08:00
|
|
|
preempt_disable(); /* protect from TOD sync and vcpu_load/put */
|
|
|
|
|
do {
|
|
|
|
|
seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount);
|
|
|
|
|
/*
|
|
|
|
|
* If the writer would ever execute a read in the critical
|
|
|
|
|
* section, e.g. in irq context, we have a deadlock.
|
|
|
|
|
*/
|
|
|
|
|
WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu);
|
|
|
|
|
value = vcpu->arch.sie_block->cputm;
|
|
|
|
|
/* if cputm_start is 0, accounting is being started/stopped */
|
|
|
|
|
if (likely(vcpu->arch.cputm_start))
|
|
|
|
|
value -= get_tod_clock_fast() - vcpu->arch.cputm_start;
|
|
|
|
|
} while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1));
|
|
|
|
|
preempt_enable();
|
2016-02-15 16:42:25 +08:00
|
|
|
return value;
|
2016-02-15 16:40:12 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
|
|
|
|
|
{
|
s390/kernel: lazy restore fpu registers
Improve the save and restore behavior of FPU register contents to use the
vector extension within the kernel.
The kernel does not use floating-point or vector registers and, therefore,
saving and restoring the FPU register contents are performed for handling
signals or switching processes only. To prepare for using vector
instructions and vector registers within the kernel, enhance the save
behavior and implement a lazy restore at return to user space from a
system call or interrupt.
To implement the lazy restore, the save_fpu_regs() sets a CPU information
flag, CIF_FPU, to indicate that the FPU registers must be restored.
Saving and setting CIF_FPU is performed in an atomic fashion to be
interrupt-safe. When the kernel wants to use the vector extension or
wants to change the FPU register state for a task during signal handling,
the save_fpu_regs() must be called first. The CIF_FPU flag is also set at
process switch. At return to user space, the FPU state is restored. In
particular, the FPU state includes the floating-point or vector register
contents, as well as, vector-enablement and floating-point control. The
FPU state restore and clearing CIF_FPU is also performed in an atomic
fashion.
For KVM, the restore of the FPU register state is performed when restoring
the general-purpose guest registers before the SIE instructions is started.
Because the path towards the SIE instruction is interruptible, the CIF_FPU
flag must be checked again right before going into SIE. If set, the guest
registers must be reloaded again by re-entering the outer SIE loop. This
is the same behavior as if the SIE critical section is interrupted.
Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
2015-06-10 18:53:42 +08:00
|
|
|
|
2015-03-11 23:47:33 +08:00
|
|
|
gmap_enable(vcpu->arch.enabled_gmap);
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_RUNNING);
|
2016-02-22 20:52:27 +08:00
|
|
|
if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu))
|
2016-02-15 16:42:25 +08:00
|
|
|
__start_cpu_timer_accounting(vcpu);
|
2016-02-13 03:41:56 +08:00
|
|
|
vcpu->cpu = cpu;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-02-13 03:41:56 +08:00
|
|
|
vcpu->cpu = -1;
|
2016-02-22 20:52:27 +08:00
|
|
|
if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu))
|
2016-02-15 16:42:25 +08:00
|
|
|
__stop_cpu_timer_accounting(vcpu);
|
2018-01-24 01:05:30 +08:00
|
|
|
kvm_s390_clear_cpuflags(vcpu, CPUSTAT_RUNNING);
|
2015-03-11 23:47:33 +08:00
|
|
|
vcpu->arch.enabled_gmap = gmap_get_enabled();
|
|
|
|
|
gmap_disable(vcpu->arch.enabled_gmap);
|
s390/kernel: lazy restore fpu registers
Improve the save and restore behavior of FPU register contents to use the
vector extension within the kernel.
The kernel does not use floating-point or vector registers and, therefore,
saving and restoring the FPU register contents are performed for handling
signals or switching processes only. To prepare for using vector
instructions and vector registers within the kernel, enhance the save
behavior and implement a lazy restore at return to user space from a
system call or interrupt.
To implement the lazy restore, the save_fpu_regs() sets a CPU information
flag, CIF_FPU, to indicate that the FPU registers must be restored.
Saving and setting CIF_FPU is performed in an atomic fashion to be
interrupt-safe. When the kernel wants to use the vector extension or
wants to change the FPU register state for a task during signal handling,
the save_fpu_regs() must be called first. The CIF_FPU flag is also set at
process switch. At return to user space, the FPU state is restored. In
particular, the FPU state includes the floating-point or vector register
contents, as well as, vector-enablement and floating-point control. The
FPU state restore and clearing CIF_FPU is also performed in an atomic
fashion.
For KVM, the restore of the FPU register state is performed when restoring
the general-purpose guest registers before the SIE instructions is started.
Because the path towards the SIE instruction is interruptible, the CIF_FPU
flag must be checked again right before going into SIE. If set, the guest
registers must be reloaded again by re-entering the outer SIE loop. This
is the same behavior as if the SIE critical section is interrupted.
Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
2015-06-10 18:53:42 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
/* this equals initial cpu reset in pop, but we don't switch to ESA */
|
|
|
|
|
vcpu->arch.sie_block->gpsw.mask = 0UL;
|
|
|
|
|
vcpu->arch.sie_block->gpsw.addr = 0UL;
|
2012-01-11 18:19:32 +08:00
|
|
|
kvm_s390_set_prefix(vcpu, 0);
|
2016-02-15 16:40:12 +08:00
|
|
|
kvm_s390_set_cpu_timer(vcpu, 0);
|
2008-03-26 01:47:20 +08:00
|
|
|
vcpu->arch.sie_block->ckc = 0UL;
|
|
|
|
|
vcpu->arch.sie_block->todpr = 0;
|
|
|
|
|
memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
|
2018-04-30 23:55:24 +08:00
|
|
|
vcpu->arch.sie_block->gcr[0] = CR0_UNUSED_56 |
|
|
|
|
|
CR0_INTERRUPT_KEY_SUBMASK |
|
|
|
|
|
CR0_MEASUREMENT_ALERT_SUBMASK;
|
|
|
|
|
vcpu->arch.sie_block->gcr[14] = CR14_UNUSED_32 |
|
|
|
|
|
CR14_UNUSED_33 |
|
|
|
|
|
CR14_EXTERNAL_DAMAGE_SUBMASK;
|
2016-01-15 05:12:47 +08:00
|
|
|
/* make sure the new fpc will be lazily loaded */
|
|
|
|
|
save_fpu_regs();
|
|
|
|
|
current->thread.fpu.fpc = 0;
|
2008-03-26 01:47:20 +08:00
|
|
|
vcpu->arch.sie_block->gbea = 1;
|
2014-02-10 22:32:19 +08:00
|
|
|
vcpu->arch.sie_block->pp = 0;
|
2018-01-17 21:44:34 +08:00
|
|
|
vcpu->arch.sie_block->fpf &= ~FPF_BPBC;
|
2013-10-07 23:11:48 +08:00
|
|
|
vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
|
|
|
|
|
kvm_clear_async_pf_completion_queue(vcpu);
|
2014-04-10 23:35:00 +08:00
|
|
|
if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
|
|
|
|
|
kvm_s390_vcpu_stop(vcpu);
|
2014-02-11 20:48:07 +08:00
|
|
|
kvm_s390_clear_local_irqs(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2014-12-04 22:47:07 +08:00
|
|
|
void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
|
2012-11-28 09:29:02 +08:00
|
|
|
{
|
2014-11-25 22:46:02 +08:00
|
|
|
mutex_lock(&vcpu->kvm->lock);
|
2015-05-13 16:58:41 +08:00
|
|
|
preempt_disable();
|
2014-11-25 22:46:02 +08:00
|
|
|
vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch;
|
2018-02-07 19:46:44 +08:00
|
|
|
vcpu->arch.sie_block->epdx = vcpu->kvm->arch.epdx;
|
2015-05-13 16:58:41 +08:00
|
|
|
preempt_enable();
|
2014-11-25 22:46:02 +08:00
|
|
|
mutex_unlock(&vcpu->kvm->lock);
|
2015-10-12 22:27:23 +08:00
|
|
|
if (!kvm_is_ucontrol(vcpu->kvm)) {
|
2014-12-02 23:53:21 +08:00
|
|
|
vcpu->arch.gmap = vcpu->kvm->arch.gmap;
|
2015-10-12 22:29:01 +08:00
|
|
|
sca_add_vcpu(vcpu);
|
2015-10-12 22:27:23 +08:00
|
|
|
}
|
2016-06-21 20:19:51 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0)
|
|
|
|
|
vcpu->arch.sie_block->ictl |= ICTL_OPEREXC;
|
2015-03-11 23:47:33 +08:00
|
|
|
/* make vcpu_load load the right gmap on the first trigger */
|
|
|
|
|
vcpu->arch.enabled_gmap = vcpu->arch.gmap;
|
2012-11-28 09:29:02 +08:00
|
|
|
}
|
|
|
|
|
|
2014-06-28 02:46:01 +08:00
|
|
|
static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2018-09-26 07:16:18 +08:00
|
|
|
/*
|
|
|
|
|
* If the AP instructions are not being interpreted and the MSAX3
|
|
|
|
|
* facility is not configured for the guest, there is nothing to set up.
|
|
|
|
|
*/
|
|
|
|
|
if (!vcpu->kvm->arch.crypto.apie && !test_kvm_facility(vcpu->kvm, 76))
|
2014-06-28 02:46:01 +08:00
|
|
|
return;
|
|
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd;
|
2014-09-03 16:13:53 +08:00
|
|
|
vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA);
|
2018-09-26 07:16:39 +08:00
|
|
|
vcpu->arch.sie_block->eca &= ~ECA_APIE;
|
2014-09-03 16:13:53 +08:00
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
if (vcpu->kvm->arch.crypto.apie)
|
|
|
|
|
vcpu->arch.sie_block->eca |= ECA_APIE;
|
2014-09-03 16:13:53 +08:00
|
|
|
|
2018-09-26 07:16:18 +08:00
|
|
|
/* Set up protected key support */
|
2014-09-03 16:13:53 +08:00
|
|
|
if (vcpu->kvm->arch.crypto.aes_kw)
|
|
|
|
|
vcpu->arch.sie_block->ecb3 |= ECB3_AES;
|
|
|
|
|
if (vcpu->kvm->arch.crypto.dea_kw)
|
|
|
|
|
vcpu->arch.sie_block->ecb3 |= ECB3_DEA;
|
2014-06-28 02:46:01 +08:00
|
|
|
}
|
|
|
|
|
|
2014-03-25 20:47:11 +08:00
|
|
|
void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
free_page(vcpu->arch.sie_block->cbrlo);
|
|
|
|
|
vcpu->arch.sie_block->cbrlo = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
|
|
|
|
|
if (!vcpu->arch.sie_block->cbrlo)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-27 21:32:11 +08:00
|
|
|
static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model;
|
|
|
|
|
|
|
|
|
|
vcpu->arch.sie_block->ibc = model->ibc;
|
2015-12-02 16:43:29 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 7))
|
2015-12-02 15:53:52 +08:00
|
|
|
vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list;
|
2015-02-27 21:32:11 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2014-03-25 20:47:11 +08:00
|
|
|
int rc = 0;
|
2013-04-17 23:36:29 +08:00
|
|
|
|
2011-11-17 18:00:41 +08:00
|
|
|
atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
|
|
|
|
|
CPUSTAT_SM |
|
2015-03-31 20:39:49 +08:00
|
|
|
CPUSTAT_STOPPED);
|
|
|
|
|
|
2015-02-18 18:13:03 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 78))
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED2);
|
2015-02-18 18:13:03 +08:00
|
|
|
else if (test_kvm_facility(vcpu->kvm, 8))
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_GED);
|
2015-03-31 20:39:49 +08:00
|
|
|
|
2015-02-27 21:32:11 +08:00
|
|
|
kvm_s390_vcpu_setup_model(vcpu);
|
|
|
|
|
|
2016-04-12 17:07:49 +08:00
|
|
|
/* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */
|
|
|
|
|
if (MACHINE_HAS_ESOP)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb |= ECB_HOSTPROTINT;
|
2016-03-04 19:23:55 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 9))
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb |= ECB_SRSI;
|
2016-04-22 22:26:49 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 73))
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb |= ECB_TE;
|
2013-06-28 19:30:24 +08:00
|
|
|
|
2018-02-16 19:16:14 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 8) && vcpu->kvm->arch.use_pfmfi)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb2 |= ECB2_PFMFI;
|
2016-08-04 15:57:36 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 130))
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb2 |= ECB2_IEP;
|
|
|
|
|
vcpu->arch.sie_block->eca = ECA_MVPGI | ECA_PROTEXCI;
|
2016-04-04 21:49:34 +08:00
|
|
|
if (sclp.has_cei)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->eca |= ECA_CEI;
|
2016-04-04 21:46:26 +08:00
|
|
|
if (sclp.has_ib)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->eca |= ECA_IB;
|
2015-05-06 19:18:59 +08:00
|
|
|
if (sclp.has_siif)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->eca |= ECA_SII;
|
2015-05-06 19:18:59 +08:00
|
|
|
if (sclp.has_sigpif)
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->eca |= ECA_SIGPI;
|
2015-03-16 23:05:41 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 129)) {
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->eca |= ECA_VX;
|
|
|
|
|
vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT;
|
2014-05-01 01:39:46 +08:00
|
|
|
}
|
2016-07-27 03:29:44 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 139))
|
|
|
|
|
vcpu->arch.sie_block->ecd |= ECD_MEF;
|
2018-03-09 00:08:49 +08:00
|
|
|
if (test_kvm_facility(vcpu->kvm, 156))
|
|
|
|
|
vcpu->arch.sie_block->ecd |= ECD_ETOKENF;
|
2017-06-12 20:15:19 +08:00
|
|
|
if (vcpu->arch.sie_block->gd) {
|
|
|
|
|
vcpu->arch.sie_block->eca |= ECA_AIV;
|
|
|
|
|
VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u",
|
|
|
|
|
vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id);
|
|
|
|
|
}
|
2016-11-29 14:17:55 +08:00
|
|
|
vcpu->arch.sie_block->sdnxo = ((unsigned long) &vcpu->run->s.regs.sdnx)
|
|
|
|
|
| SDNXC;
|
2016-01-07 18:24:29 +08:00
|
|
|
vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb;
|
2017-02-25 05:12:56 +08:00
|
|
|
|
|
|
|
|
if (sclp.has_kss)
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_KSS);
|
2017-02-25 05:12:56 +08:00
|
|
|
else
|
|
|
|
|
vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
|
2013-01-30 00:48:20 +08:00
|
|
|
|
2015-05-07 21:41:57 +08:00
|
|
|
if (vcpu->kvm->arch.use_cmma) {
|
2014-03-25 20:47:11 +08:00
|
|
|
rc = kvm_s390_vcpu_setup_cmma(vcpu);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-04-17 23:36:29 +08:00
|
|
|
}
|
2014-12-12 22:17:31 +08:00
|
|
|
hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
2009-05-12 23:21:49 +08:00
|
|
|
vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
|
2015-02-02 22:42:51 +08:00
|
|
|
|
2018-09-01 00:51:19 +08:00
|
|
|
vcpu->arch.sie_block->hpid = HPID_KVM;
|
|
|
|
|
|
2014-06-28 02:46:01 +08:00
|
|
|
kvm_s390_vcpu_crypto_setup(vcpu);
|
|
|
|
|
|
2014-03-25 20:47:11 +08:00
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
|
|
|
|
|
unsigned int id)
|
|
|
|
|
{
|
2011-10-18 18:27:12 +08:00
|
|
|
struct kvm_vcpu *vcpu;
|
2013-06-28 19:30:24 +08:00
|
|
|
struct sie_page *sie_page;
|
2011-10-18 18:27:12 +08:00
|
|
|
int rc = -EINVAL;
|
|
|
|
|
|
2015-10-12 18:57:22 +08:00
|
|
|
if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id))
|
2011-10-18 18:27:12 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
rc = -ENOMEM;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2013-06-12 19:54:54 +08:00
|
|
|
vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
|
2008-03-26 01:47:20 +08:00
|
|
|
if (!vcpu)
|
2011-10-18 18:27:12 +08:00
|
|
|
goto out;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
KVM: s390: Backup the guest's machine check info
When a machine check happens in the guest, related mcck info (mcic,
external damage code, ...) is stored in the vcpu's lowcore on the host.
Then the machine check handler's low-level part is executed, followed
by the high-level part.
If the high-level part's execution is interrupted by a new machine check
happening on the same vcpu on the host, the mcck info in the lowcore is
overwritten with the new machine check's data.
If the high-level part's execution is scheduled to a different cpu,
the mcck info in the lowcore is uncertain.
Therefore, for both cases, the further reinjection to the guest will use
the wrong data.
Let's backup the mcck info in the lowcore to the sie page
for further reinjection, so that the right data will be used.
Add new member into struct sie_page to store related machine check's
info of mcic, failing storage address and external damage code.
Signed-off-by: QingFeng Hao <haoqf@linux.vnet.ibm.com>
Acked-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
2017-06-07 17:41:19 +08:00
|
|
|
BUILD_BUG_ON(sizeof(struct sie_page) != 4096);
|
2013-06-28 19:30:24 +08:00
|
|
|
sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
|
|
|
|
|
if (!sie_page)
|
2008-03-26 01:47:20 +08:00
|
|
|
goto out_free_cpu;
|
|
|
|
|
|
2013-06-28 19:30:24 +08:00
|
|
|
vcpu->arch.sie_block = &sie_page->sie_block;
|
|
|
|
|
vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
|
|
|
|
|
|
2015-04-16 18:32:41 +08:00
|
|
|
/* the real guest size will always be smaller than msl */
|
|
|
|
|
vcpu->arch.sie_block->mso = 0;
|
|
|
|
|
vcpu->arch.sie_block->msl = sclp.hamax;
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
vcpu->arch.sie_block->icpua = id;
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
spin_lock_init(&vcpu->arch.local_int.lock);
|
2019-01-31 16:52:38 +08:00
|
|
|
vcpu->arch.sie_block->gd = (u32)(u64)kvm->arch.gisa_int.origin;
|
2017-06-23 19:51:25 +08:00
|
|
|
if (vcpu->arch.sie_block->gd && sclp.has_gisaf)
|
|
|
|
|
vcpu->arch.sie_block->gd |= GISA_FORMAT1;
|
2016-02-18 04:53:33 +08:00
|
|
|
seqcount_init(&vcpu->arch.cputm_seqcount);
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
rc = kvm_vcpu_init(vcpu, kvm, id);
|
|
|
|
|
if (rc)
|
2016-01-15 05:12:47 +08:00
|
|
|
goto out_free_sie_block;
|
2015-12-08 23:55:27 +08:00
|
|
|
VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu,
|
2008-03-26 01:47:20 +08:00
|
|
|
vcpu->arch.sie_block);
|
2012-07-23 23:20:30 +08:00
|
|
|
trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
|
2008-03-26 01:47:20 +08:00
|
|
|
|
|
|
|
|
return vcpu;
|
2010-03-09 14:37:53 +08:00
|
|
|
out_free_sie_block:
|
|
|
|
|
free_page((unsigned long)(vcpu->arch.sie_block));
|
2008-03-26 01:47:20 +08:00
|
|
|
out_free_cpu:
|
2013-06-12 19:54:54 +08:00
|
|
|
kmem_cache_free(kvm_vcpu_cache, vcpu);
|
2011-10-18 18:27:12 +08:00
|
|
|
out:
|
2008-03-26 01:47:20 +08:00
|
|
|
return ERR_PTR(rc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2014-08-05 23:40:47 +08:00
|
|
|
return kvm_s390_vcpu_has_irq(vcpu, 0);
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2017-08-08 12:05:32 +08:00
|
|
|
bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2017-08-08 12:05:34 +08:00
|
|
|
return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE);
|
2017-08-08 12:05:32 +08:00
|
|
|
}
|
|
|
|
|
|
2015-04-14 18:17:34 +08:00
|
|
|
void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu)
|
2013-05-17 20:41:35 +08:00
|
|
|
{
|
2015-04-24 07:12:32 +08:00
|
|
|
atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
|
2015-05-12 14:41:40 +08:00
|
|
|
exit_sie(vcpu);
|
2013-05-17 20:41:35 +08:00
|
|
|
}
|
|
|
|
|
|
2015-04-14 18:17:34 +08:00
|
|
|
void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu)
|
2013-05-17 20:41:35 +08:00
|
|
|
{
|
2015-04-24 07:12:32 +08:00
|
|
|
atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
|
2013-05-17 20:41:35 +08:00
|
|
|
}
|
|
|
|
|
|
2015-04-09 19:49:04 +08:00
|
|
|
static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2015-04-24 07:12:32 +08:00
|
|
|
atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
|
2015-05-12 14:41:40 +08:00
|
|
|
exit_sie(vcpu);
|
2015-04-09 19:49:04 +08:00
|
|
|
}
|
|
|
|
|
|
2018-09-26 07:16:16 +08:00
|
|
|
bool kvm_s390_vcpu_sie_inhibited(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
return atomic_read(&vcpu->arch.sie_block->prog20) &
|
|
|
|
|
(PROG_BLOCK_SIE | PROG_REQUEST);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-09 19:49:04 +08:00
|
|
|
static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2015-09-16 21:13:50 +08:00
|
|
|
atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
|
2015-04-09 19:49:04 +08:00
|
|
|
}
|
|
|
|
|
|
2013-05-17 20:41:35 +08:00
|
|
|
/*
|
2018-09-26 07:16:16 +08:00
|
|
|
* Kick a guest cpu out of (v)SIE and wait until (v)SIE is not running.
|
2013-05-17 20:41:35 +08:00
|
|
|
* If the CPU is not running (e.g. waiting as idle) the function will
|
|
|
|
|
* return immediately. */
|
|
|
|
|
void exit_sie(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOP_INT);
|
2018-09-26 07:16:16 +08:00
|
|
|
kvm_s390_vsie_kick(vcpu);
|
2013-05-17 20:41:35 +08:00
|
|
|
while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
|
|
|
|
|
cpu_relax();
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-09 19:49:04 +08:00
|
|
|
/* Kick a guest cpu out of SIE to process a request synchronously */
|
|
|
|
|
void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu)
|
2013-05-17 20:41:35 +08:00
|
|
|
{
|
2015-04-09 19:49:04 +08:00
|
|
|
kvm_make_request(req, vcpu);
|
|
|
|
|
kvm_s390_vcpu_request(vcpu);
|
2013-05-17 20:41:35 +08:00
|
|
|
}
|
|
|
|
|
|
2016-03-08 18:52:54 +08:00
|
|
|
static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start,
|
|
|
|
|
unsigned long end)
|
2013-05-17 20:41:36 +08:00
|
|
|
{
|
|
|
|
|
struct kvm *kvm = gmap->private;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
2016-03-08 18:52:54 +08:00
|
|
|
unsigned long prefix;
|
|
|
|
|
int i;
|
2013-05-17 20:41:36 +08:00
|
|
|
|
2015-04-27 22:29:34 +08:00
|
|
|
if (gmap_is_shadow(gmap))
|
|
|
|
|
return;
|
2016-03-08 18:52:54 +08:00
|
|
|
if (start >= 1UL << 31)
|
|
|
|
|
/* We are only interested in prefix pages */
|
|
|
|
|
return;
|
2013-05-17 20:41:36 +08:00
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
|
|
|
/* match against both prefix pages */
|
2016-03-08 18:52:54 +08:00
|
|
|
prefix = kvm_s390_get_prefix(vcpu);
|
|
|
|
|
if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) {
|
|
|
|
|
VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx",
|
|
|
|
|
start, end);
|
2015-04-09 19:49:04 +08:00
|
|
|
kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu);
|
2013-05-17 20:41:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-09 05:44:24 +08:00
|
|
|
int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
/* kvm common code refers to this, but never calls it */
|
|
|
|
|
BUG();
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-15 20:15:26 +08:00
|
|
|
static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_one_reg *reg)
|
|
|
|
|
{
|
|
|
|
|
int r = -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (reg->id) {
|
2012-05-15 20:15:27 +08:00
|
|
|
case KVM_REG_S390_TODPR:
|
|
|
|
|
r = put_user(vcpu->arch.sie_block->todpr,
|
|
|
|
|
(u32 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_EPOCHDIFF:
|
|
|
|
|
r = put_user(vcpu->arch.sie_block->epoch,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2012-05-15 20:15:28 +08:00
|
|
|
case KVM_REG_S390_CPU_TIMER:
|
2016-02-15 16:40:12 +08:00
|
|
|
r = put_user(kvm_s390_get_cpu_timer(vcpu),
|
2012-05-15 20:15:28 +08:00
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_CLOCK_COMP:
|
|
|
|
|
r = put_user(vcpu->arch.sie_block->ckc,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2013-09-30 16:55:33 +08:00
|
|
|
case KVM_REG_S390_PFTOKEN:
|
|
|
|
|
r = put_user(vcpu->arch.pfault_token,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_PFCOMPARE:
|
|
|
|
|
r = put_user(vcpu->arch.pfault_compare,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_PFSELECT:
|
|
|
|
|
r = put_user(vcpu->arch.pfault_select,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2014-02-10 22:32:19 +08:00
|
|
|
case KVM_REG_S390_PP:
|
|
|
|
|
r = put_user(vcpu->arch.sie_block->pp,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2014-02-10 22:39:23 +08:00
|
|
|
case KVM_REG_S390_GBEA:
|
|
|
|
|
r = put_user(vcpu->arch.sie_block->gbea,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2012-05-15 20:15:26 +08:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_one_reg *reg)
|
|
|
|
|
{
|
|
|
|
|
int r = -EINVAL;
|
2016-02-15 16:40:12 +08:00
|
|
|
__u64 val;
|
2012-05-15 20:15:26 +08:00
|
|
|
|
|
|
|
|
switch (reg->id) {
|
2012-05-15 20:15:27 +08:00
|
|
|
case KVM_REG_S390_TODPR:
|
|
|
|
|
r = get_user(vcpu->arch.sie_block->todpr,
|
|
|
|
|
(u32 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_EPOCHDIFF:
|
|
|
|
|
r = get_user(vcpu->arch.sie_block->epoch,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2012-05-15 20:15:28 +08:00
|
|
|
case KVM_REG_S390_CPU_TIMER:
|
2016-02-15 16:40:12 +08:00
|
|
|
r = get_user(val, (u64 __user *)reg->addr);
|
|
|
|
|
if (!r)
|
|
|
|
|
kvm_s390_set_cpu_timer(vcpu, val);
|
2012-05-15 20:15:28 +08:00
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_CLOCK_COMP:
|
|
|
|
|
r = get_user(vcpu->arch.sie_block->ckc,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2013-09-30 16:55:33 +08:00
|
|
|
case KVM_REG_S390_PFTOKEN:
|
|
|
|
|
r = get_user(vcpu->arch.pfault_token,
|
|
|
|
|
(u64 __user *)reg->addr);
|
2014-10-09 21:01:38 +08:00
|
|
|
if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
|
|
|
|
|
kvm_clear_async_pf_completion_queue(vcpu);
|
2013-09-30 16:55:33 +08:00
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_PFCOMPARE:
|
|
|
|
|
r = get_user(vcpu->arch.pfault_compare,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_REG_S390_PFSELECT:
|
|
|
|
|
r = get_user(vcpu->arch.pfault_select,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2014-02-10 22:32:19 +08:00
|
|
|
case KVM_REG_S390_PP:
|
|
|
|
|
r = get_user(vcpu->arch.sie_block->pp,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2014-02-10 22:39:23 +08:00
|
|
|
case KVM_REG_S390_GBEA:
|
|
|
|
|
r = get_user(vcpu->arch.sie_block->gbea,
|
|
|
|
|
(u64 __user *)reg->addr);
|
|
|
|
|
break;
|
2012-05-15 20:15:26 +08:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
2012-03-09 05:44:24 +08:00
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
kvm_s390_vcpu_initial_reset(vcpu);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
|
|
|
|
|
{
|
2017-12-05 04:35:27 +08:00
|
|
|
vcpu_load(vcpu);
|
2012-01-11 18:20:32 +08:00
|
|
|
memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs));
|
2017-12-05 04:35:27 +08:00
|
|
|
vcpu_put(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
|
|
|
|
|
{
|
2017-12-05 04:35:26 +08:00
|
|
|
vcpu_load(vcpu);
|
2012-01-11 18:20:32 +08:00
|
|
|
memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
|
2017-12-05 04:35:26 +08:00
|
|
|
vcpu_put(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
2017-12-05 04:35:29 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2012-01-11 18:20:33 +08:00
|
|
|
memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
|
2008-03-26 01:47:20 +08:00
|
|
|
memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
|
2017-12-05 04:35:29 +08:00
|
|
|
|
|
|
|
|
vcpu_put(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
|
|
|
|
{
|
2017-12-05 04:35:28 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2012-01-11 18:20:33 +08:00
|
|
|
memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
|
2008-03-26 01:47:20 +08:00
|
|
|
memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
|
2017-12-05 04:35:28 +08:00
|
|
|
|
|
|
|
|
vcpu_put(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
|
|
|
|
|
{
|
2017-12-05 04:35:35 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
|
|
|
|
if (test_fp_ctl(fpu->fpc)) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2016-11-22 16:29:38 +08:00
|
|
|
vcpu->run->s.regs.fpc = fpu->fpc;
|
2016-01-15 05:12:47 +08:00
|
|
|
if (MACHINE_HAS_VX)
|
2016-08-16 20:38:24 +08:00
|
|
|
convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs,
|
|
|
|
|
(freg_t *) fpu->fprs);
|
2016-01-15 05:12:47 +08:00
|
|
|
else
|
2016-08-16 20:38:24 +08:00
|
|
|
memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs));
|
2017-12-05 04:35:35 +08:00
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
vcpu_put(vcpu);
|
|
|
|
|
return ret;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
|
|
|
|
|
{
|
2017-12-05 04:35:34 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2016-01-15 05:12:47 +08:00
|
|
|
/* make sure we have the latest values */
|
|
|
|
|
save_fpu_regs();
|
|
|
|
|
if (MACHINE_HAS_VX)
|
2016-08-16 20:38:24 +08:00
|
|
|
convert_vx_to_fp((freg_t *) fpu->fprs,
|
|
|
|
|
(__vector128 *) vcpu->run->s.regs.vrs);
|
2016-01-15 05:12:47 +08:00
|
|
|
else
|
2016-08-16 20:38:24 +08:00
|
|
|
memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs));
|
2016-11-22 16:29:38 +08:00
|
|
|
fpu->fpc = vcpu->run->s.regs.fpc;
|
2017-12-05 04:35:34 +08:00
|
|
|
|
|
|
|
|
vcpu_put(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
|
|
|
|
|
2014-05-05 22:26:19 +08:00
|
|
|
if (!is_vcpu_stopped(vcpu))
|
2008-03-26 01:47:20 +08:00
|
|
|
rc = -EBUSY;
|
2009-11-19 21:21:16 +08:00
|
|
|
else {
|
|
|
|
|
vcpu->run->psw_mask = psw.mask;
|
|
|
|
|
vcpu->run->psw_addr = psw.addr;
|
|
|
|
|
}
|
2008-03-26 01:47:20 +08:00
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_translation *tr)
|
|
|
|
|
{
|
|
|
|
|
return -EINVAL; /* not implemented yet */
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
|
|
|
|
|
KVM_GUESTDBG_USE_HW_BP | \
|
|
|
|
|
KVM_GUESTDBG_ENABLE)
|
|
|
|
|
|
2008-12-15 20:52:10 +08:00
|
|
|
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_guest_debug *dbg)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2014-01-23 19:26:52 +08:00
|
|
|
int rc = 0;
|
|
|
|
|
|
2017-12-05 04:35:33 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
vcpu->guest_debug = 0;
|
|
|
|
|
kvm_s390_clear_bp_data(vcpu);
|
|
|
|
|
|
2017-12-05 04:35:33 +08:00
|
|
|
if (dbg->control & ~VALID_GUESTDBG_FLAGS) {
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (!sclp.has_gpere) {
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2014-01-23 19:26:52 +08:00
|
|
|
|
|
|
|
|
if (dbg->control & KVM_GUESTDBG_ENABLE) {
|
|
|
|
|
vcpu->guest_debug = dbg->control;
|
|
|
|
|
/* enforce guest PER */
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_P);
|
2014-01-23 19:26:52 +08:00
|
|
|
|
|
|
|
|
if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
|
|
|
|
|
rc = kvm_s390_import_bp_data(vcpu, dbg);
|
|
|
|
|
} else {
|
2018-01-24 01:05:30 +08:00
|
|
|
kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P);
|
2014-01-23 19:26:52 +08:00
|
|
|
vcpu->arch.guestdbg.last_bp = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rc) {
|
|
|
|
|
vcpu->guest_debug = 0;
|
|
|
|
|
kvm_s390_clear_bp_data(vcpu);
|
2018-01-24 01:05:30 +08:00
|
|
|
kvm_s390_clear_cpuflags(vcpu, CPUSTAT_P);
|
2014-01-23 19:26:52 +08:00
|
|
|
}
|
|
|
|
|
|
2017-12-05 04:35:33 +08:00
|
|
|
out:
|
|
|
|
|
vcpu_put(vcpu);
|
2014-01-23 19:26:52 +08:00
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2008-04-12 00:24:45 +08:00
|
|
|
int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_mp_state *mp_state)
|
|
|
|
|
{
|
2017-12-05 04:35:30 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2014-04-10 23:35:00 +08:00
|
|
|
/* CHECK_STOP and LOAD are not supported yet */
|
2017-12-05 04:35:30 +08:00
|
|
|
ret = is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED :
|
|
|
|
|
KVM_MP_STATE_OPERATING;
|
|
|
|
|
|
|
|
|
|
vcpu_put(vcpu);
|
|
|
|
|
return ret;
|
2008-04-12 00:24:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_mp_state *mp_state)
|
|
|
|
|
{
|
2014-04-10 23:35:00 +08:00
|
|
|
int rc = 0;
|
|
|
|
|
|
2017-12-05 04:35:31 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2014-04-10 23:35:00 +08:00
|
|
|
/* user space knows about this interface - let it control the state */
|
|
|
|
|
vcpu->kvm->arch.user_cpu_state_ctrl = 1;
|
|
|
|
|
|
|
|
|
|
switch (mp_state->mp_state) {
|
|
|
|
|
case KVM_MP_STATE_STOPPED:
|
|
|
|
|
kvm_s390_vcpu_stop(vcpu);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_MP_STATE_OPERATING:
|
|
|
|
|
kvm_s390_vcpu_start(vcpu);
|
|
|
|
|
break;
|
|
|
|
|
case KVM_MP_STATE_LOAD:
|
|
|
|
|
case KVM_MP_STATE_CHECK_STOP:
|
|
|
|
|
/* fall through - CHECK_STOP and LOAD are not supported yet */
|
|
|
|
|
default:
|
|
|
|
|
rc = -ENXIO;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-05 04:35:31 +08:00
|
|
|
vcpu_put(vcpu);
|
2014-04-10 23:35:00 +08:00
|
|
|
return rc;
|
2008-04-12 00:24:45 +08:00
|
|
|
}
|
|
|
|
|
|
2014-03-14 18:00:21 +08:00
|
|
|
static bool ibs_enabled(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2018-01-24 01:05:31 +08:00
|
|
|
return kvm_s390_test_cpuflags(vcpu, CPUSTAT_IBS);
|
2014-03-14 18:00:21 +08:00
|
|
|
}
|
|
|
|
|
|
2013-05-17 20:41:36 +08:00
|
|
|
static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2014-03-14 18:00:21 +08:00
|
|
|
retry:
|
2015-04-09 19:49:04 +08:00
|
|
|
kvm_s390_vcpu_request_handled(vcpu);
|
2017-06-04 20:43:52 +08:00
|
|
|
if (!kvm_request_pending(vcpu))
|
2015-07-28 21:03:05 +08:00
|
|
|
return 0;
|
2013-05-17 20:41:36 +08:00
|
|
|
/*
|
|
|
|
|
* We use MMU_RELOAD just to re-arm the ipte notifier for the
|
2016-03-08 18:54:42 +08:00
|
|
|
* guest prefix page. gmap_mprotect_notify will wait on the ptl lock.
|
2013-05-17 20:41:36 +08:00
|
|
|
* This ensures that the ipte instruction for this request has
|
|
|
|
|
* already finished. We might race against a second unmapper that
|
|
|
|
|
* wants to set the blocking bit. Lets just retry the request loop.
|
|
|
|
|
*/
|
2014-03-14 18:00:21 +08:00
|
|
|
if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
|
2013-05-17 20:41:36 +08:00
|
|
|
int rc;
|
2016-03-08 18:54:42 +08:00
|
|
|
rc = gmap_mprotect_notify(vcpu->arch.gmap,
|
|
|
|
|
kvm_s390_get_prefix(vcpu),
|
|
|
|
|
PAGE_SIZE * 2, PROT_WRITE);
|
2016-08-03 22:39:55 +08:00
|
|
|
if (rc) {
|
|
|
|
|
kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
|
2013-05-17 20:41:36 +08:00
|
|
|
return rc;
|
2016-08-03 22:39:55 +08:00
|
|
|
}
|
2014-03-14 18:00:21 +08:00
|
|
|
goto retry;
|
2013-05-17 20:41:36 +08:00
|
|
|
}
|
2014-03-14 18:00:21 +08:00
|
|
|
|
2014-07-29 14:53:36 +08:00
|
|
|
if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) {
|
|
|
|
|
vcpu->arch.sie_block->ihcpu = 0xffff;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-14 18:00:21 +08:00
|
|
|
if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
|
|
|
|
|
if (!ibs_enabled(vcpu)) {
|
|
|
|
|
trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_IBS);
|
2014-03-14 18:00:21 +08:00
|
|
|
}
|
|
|
|
|
goto retry;
|
2013-05-17 20:41:36 +08:00
|
|
|
}
|
2014-03-14 18:00:21 +08:00
|
|
|
|
|
|
|
|
if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
|
|
|
|
|
if (ibs_enabled(vcpu)) {
|
|
|
|
|
trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
|
2018-01-24 01:05:30 +08:00
|
|
|
kvm_s390_clear_cpuflags(vcpu, CPUSTAT_IBS);
|
2014-03-14 18:00:21 +08:00
|
|
|
}
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-21 20:19:51 +08:00
|
|
|
if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) {
|
|
|
|
|
vcpu->arch.sie_block->ictl |= ICTL_OPEREXC;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-04 23:54:42 +08:00
|
|
|
if (kvm_check_request(KVM_REQ_START_MIGRATION, vcpu)) {
|
|
|
|
|
/*
|
2018-02-16 19:16:14 +08:00
|
|
|
* Disable CMM virtualization; we will emulate the ESSA
|
2016-08-04 23:54:42 +08:00
|
|
|
* instruction manually, in order to provide additional
|
|
|
|
|
* functionalities needed for live migration.
|
|
|
|
|
*/
|
|
|
|
|
vcpu->arch.sie_block->ecb2 &= ~ECB2_CMMA;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (kvm_check_request(KVM_REQ_STOP_MIGRATION, vcpu)) {
|
|
|
|
|
/*
|
2018-02-16 19:16:14 +08:00
|
|
|
* Re-enable CMM virtualization if CMMA is available and
|
|
|
|
|
* CMM has been used.
|
2016-08-04 23:54:42 +08:00
|
|
|
*/
|
|
|
|
|
if ((vcpu->kvm->arch.use_cmma) &&
|
2018-02-16 19:16:14 +08:00
|
|
|
(vcpu->kvm->mm->context.uses_cmm))
|
2016-08-04 23:54:42 +08:00
|
|
|
vcpu->arch.sie_block->ecb2 |= ECB2_CMMA;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-13 22:54:32 +08:00
|
|
|
/* nothing to do, just clear the request */
|
2017-04-27 04:32:19 +08:00
|
|
|
kvm_clear_request(KVM_REQ_UNHALT, vcpu);
|
2018-09-26 07:16:17 +08:00
|
|
|
/* we left the vsie handler, nothing to do, just clear the request */
|
|
|
|
|
kvm_clear_request(KVM_REQ_VSIE_RESTART, vcpu);
|
2014-05-13 22:54:32 +08:00
|
|
|
|
2013-05-17 20:41:36 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-07 19:46:43 +08:00
|
|
|
void kvm_s390_set_tod_clock(struct kvm *kvm,
|
|
|
|
|
const struct kvm_s390_vm_tod_clock *gtod)
|
2016-07-27 03:29:44 +08:00
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
struct kvm_s390_tod_clock_ext htod;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
|
|
get_tod_clock_ext((char *)&htod);
|
|
|
|
|
|
|
|
|
|
kvm->arch.epoch = gtod->tod - htod.tod;
|
2018-02-07 19:46:43 +08:00
|
|
|
kvm->arch.epdx = 0;
|
|
|
|
|
if (test_kvm_facility(kvm, 139)) {
|
|
|
|
|
kvm->arch.epdx = gtod->epoch_idx - htod.epoch_idx;
|
|
|
|
|
if (kvm->arch.epoch > gtod->tod)
|
|
|
|
|
kvm->arch.epdx -= 1;
|
|
|
|
|
}
|
2016-07-27 03:29:44 +08:00
|
|
|
|
|
|
|
|
kvm_s390_vcpu_block_all(kvm);
|
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
|
|
|
vcpu->arch.sie_block->epoch = kvm->arch.epoch;
|
|
|
|
|
vcpu->arch.sie_block->epdx = kvm->arch.epdx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kvm_s390_vcpu_unblock_all(kvm);
|
|
|
|
|
preempt_enable();
|
|
|
|
|
mutex_unlock(&kvm->lock);
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-06 23:20:16 +08:00
|
|
|
/**
|
|
|
|
|
* kvm_arch_fault_in_page - fault-in guest page if necessary
|
|
|
|
|
* @vcpu: The corresponding virtual cpu
|
|
|
|
|
* @gpa: Guest physical address
|
|
|
|
|
* @writable: Whether the page should be writable or not
|
|
|
|
|
*
|
|
|
|
|
* Make sure that a guest page has been faulted-in on the host.
|
|
|
|
|
*
|
|
|
|
|
* Return: Zero on success, negative error code otherwise.
|
|
|
|
|
*/
|
|
|
|
|
long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
|
2013-06-17 22:25:18 +08:00
|
|
|
{
|
2014-04-30 22:04:25 +08:00
|
|
|
return gmap_fault(vcpu->arch.gmap, gpa,
|
|
|
|
|
writable ? FAULT_FLAG_WRITE : 0);
|
2013-06-17 22:25:18 +08:00
|
|
|
}
|
|
|
|
|
|
2013-10-07 23:11:48 +08:00
|
|
|
static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
|
|
|
|
|
unsigned long token)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_s390_interrupt inti;
|
2014-07-29 21:11:49 +08:00
|
|
|
struct kvm_s390_irq irq;
|
2013-10-07 23:11:48 +08:00
|
|
|
|
|
|
|
|
if (start_token) {
|
2014-07-29 21:11:49 +08:00
|
|
|
irq.u.ext.ext_params2 = token;
|
|
|
|
|
irq.type = KVM_S390_INT_PFAULT_INIT;
|
|
|
|
|
WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq));
|
2013-10-07 23:11:48 +08:00
|
|
|
} else {
|
|
|
|
|
inti.type = KVM_S390_INT_PFAULT_DONE;
|
2014-07-29 21:11:49 +08:00
|
|
|
inti.parm64 = token;
|
2013-10-07 23:11:48 +08:00
|
|
|
WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_async_pf *work)
|
|
|
|
|
{
|
|
|
|
|
trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
|
|
|
|
|
__kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_async_pf *work)
|
|
|
|
|
{
|
|
|
|
|
trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
|
|
|
|
|
__kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_async_pf *work)
|
|
|
|
|
{
|
|
|
|
|
/* s390 will always inject the page directly */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* s390 will always inject the page directly,
|
|
|
|
|
* but we still want check_async_completion to cleanup
|
|
|
|
|
*/
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
hva_t hva;
|
|
|
|
|
struct kvm_arch_async_pf arch;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
|
|
|
|
|
return 0;
|
|
|
|
|
if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
|
|
|
|
|
vcpu->arch.pfault_compare)
|
|
|
|
|
return 0;
|
|
|
|
|
if (psw_extint_disabled(vcpu))
|
|
|
|
|
return 0;
|
2014-08-05 23:40:47 +08:00
|
|
|
if (kvm_s390_vcpu_has_irq(vcpu, 0))
|
2013-10-07 23:11:48 +08:00
|
|
|
return 0;
|
2018-04-30 23:55:24 +08:00
|
|
|
if (!(vcpu->arch.sie_block->gcr[0] & CR0_SERVICE_SIGNAL_SUBMASK))
|
2013-10-07 23:11:48 +08:00
|
|
|
return 0;
|
|
|
|
|
if (!vcpu->arch.gmap->pfault_enabled)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2014-01-01 23:36:07 +08:00
|
|
|
hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
|
|
|
|
|
hva += current->thread.gmap_addr & ~PAGE_MASK;
|
|
|
|
|
if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
|
2013-10-07 23:11:48 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-12 16:33:43 +08:00
|
|
|
static int vcpu_pre_run(struct kvm_vcpu *vcpu)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2013-09-12 16:33:43 +08:00
|
|
|
int rc, cpuflags;
|
2012-01-04 17:25:22 +08:00
|
|
|
|
2013-10-07 23:11:48 +08:00
|
|
|
/*
|
|
|
|
|
* On s390 notifications for arriving pages will be delivered directly
|
|
|
|
|
* to the guest but the house keeping for completed pfaults is
|
|
|
|
|
* handled outside the worker.
|
|
|
|
|
*/
|
|
|
|
|
kvm_check_async_pf_completion(vcpu);
|
|
|
|
|
|
2015-12-02 21:27:03 +08:00
|
|
|
vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14];
|
|
|
|
|
vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15];
|
2008-03-26 01:47:20 +08:00
|
|
|
|
|
|
|
|
if (need_resched())
|
|
|
|
|
schedule();
|
|
|
|
|
|
2014-04-15 18:55:07 +08:00
|
|
|
if (test_cpu_flag(CIF_MCCK_PENDING))
|
2008-05-21 19:37:34 +08:00
|
|
|
s390_handle_mcck();
|
|
|
|
|
|
2014-04-17 16:10:30 +08:00
|
|
|
if (!kvm_is_ucontrol(vcpu->kvm)) {
|
|
|
|
|
rc = kvm_s390_deliver_pending_interrupts(vcpu);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2008-05-21 19:37:37 +08:00
|
|
|
|
2013-05-17 20:41:36 +08:00
|
|
|
rc = kvm_s390_handle_requests(vcpu);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
if (guestdbg_enabled(vcpu)) {
|
|
|
|
|
kvm_s390_backup_guest_per_regs(vcpu);
|
|
|
|
|
kvm_s390_patch_guest_per_regs(vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-31 16:52:44 +08:00
|
|
|
clear_bit(vcpu->vcpu_id, vcpu->kvm->arch.gisa_int.kicked_mask);
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
vcpu->arch.sie_block->icptcode = 0;
|
2013-09-12 16:33:43 +08:00
|
|
|
cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
|
|
|
|
|
VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
|
|
|
|
|
trace_kvm_s390_sie_enter(vcpu, cpuflags);
|
2013-07-26 21:04:00 +08:00
|
|
|
|
2013-09-12 16:33:43 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-10 23:11:01 +08:00
|
|
|
static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-01-13 00:37:58 +08:00
|
|
|
struct kvm_s390_pgm_info pgm_info = {
|
|
|
|
|
.code = PGM_ADDRESSING,
|
|
|
|
|
};
|
|
|
|
|
u8 opcode, ilen;
|
2015-02-10 23:11:01 +08:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
|
|
|
|
|
trace_kvm_s390_sie_fault(vcpu);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We want to inject an addressing exception, which is defined as a
|
|
|
|
|
* suppressing or terminating exception. However, since we came here
|
|
|
|
|
* by a DAT access exception, the PSW still points to the faulting
|
|
|
|
|
* instruction since DAT exceptions are nullifying. So we've got
|
|
|
|
|
* to look up the current opcode to get the length of the instruction
|
|
|
|
|
* to be able to forward the PSW.
|
|
|
|
|
*/
|
2016-05-24 18:00:49 +08:00
|
|
|
rc = read_guest_instr(vcpu, vcpu->arch.sie_block->gpsw.addr, &opcode, 1);
|
2016-01-13 00:37:58 +08:00
|
|
|
ilen = insn_length(opcode);
|
2016-01-13 00:40:54 +08:00
|
|
|
if (rc < 0) {
|
|
|
|
|
return rc;
|
|
|
|
|
} else if (rc) {
|
|
|
|
|
/* Instruction-Fetching Exceptions - we can't detect the ilen.
|
|
|
|
|
* Forward by arbitrary ilc, injection will take care of
|
|
|
|
|
* nullification if necessary.
|
|
|
|
|
*/
|
|
|
|
|
pgm_info = vcpu->arch.pgm;
|
|
|
|
|
ilen = 4;
|
|
|
|
|
}
|
2016-01-13 00:37:58 +08:00
|
|
|
pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID;
|
|
|
|
|
kvm_s390_forward_psw(vcpu, ilen);
|
|
|
|
|
return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
|
2015-02-10 23:11:01 +08:00
|
|
|
}
|
|
|
|
|
|
2013-09-12 16:33:43 +08:00
|
|
|
static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
|
|
|
|
|
{
|
KVM: s390: Inject machine check into the guest
If the exit flag of SIE indicates that a machine check has happened
during guest's running and needs to be injected, inject it to the guest
accordingly.
But some machine checks, e.g. Channel Report Pending (CRW), refer to
host conditions only (the guest's channel devices are not managed by
the kernel directly) and are therefore not injected into the guest.
External Damage (ED) is also not reinjected into the guest because ETR
conditions are gone in Linux and STP conditions are not enabled in the
guest, and ED contains only these 8 ETR and STP conditions.
In general, instruction-processing damage, system recovery,
storage error, service-processor damage and channel subsystem damage
will be reinjected into the guest, and the remain (System damage,
timing-facility damage, warning, ED and CRW) will be handled on the host.
Signed-off-by: QingFeng Hao <haoqf@linux.vnet.ibm.com>
Acked-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
2017-06-07 18:03:05 +08:00
|
|
|
struct mcck_volatile_info *mcck_info;
|
|
|
|
|
struct sie_page *sie_page;
|
|
|
|
|
|
2013-07-26 21:04:00 +08:00
|
|
|
VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
|
|
|
|
|
vcpu->arch.sie_block->icptcode);
|
|
|
|
|
trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
|
|
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
if (guestdbg_enabled(vcpu))
|
|
|
|
|
kvm_s390_restore_guest_per_regs(vcpu);
|
|
|
|
|
|
2015-12-02 21:27:03 +08:00
|
|
|
vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14;
|
|
|
|
|
vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15;
|
2015-10-19 22:24:28 +08:00
|
|
|
|
KVM: s390: Inject machine check into the guest
If the exit flag of SIE indicates that a machine check has happened
during guest's running and needs to be injected, inject it to the guest
accordingly.
But some machine checks, e.g. Channel Report Pending (CRW), refer to
host conditions only (the guest's channel devices are not managed by
the kernel directly) and are therefore not injected into the guest.
External Damage (ED) is also not reinjected into the guest because ETR
conditions are gone in Linux and STP conditions are not enabled in the
guest, and ED contains only these 8 ETR and STP conditions.
In general, instruction-processing damage, system recovery,
storage error, service-processor damage and channel subsystem damage
will be reinjected into the guest, and the remain (System damage,
timing-facility damage, warning, ED and CRW) will be handled on the host.
Signed-off-by: QingFeng Hao <haoqf@linux.vnet.ibm.com>
Acked-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
2017-06-07 18:03:05 +08:00
|
|
|
if (exit_reason == -EINTR) {
|
|
|
|
|
VCPU_EVENT(vcpu, 3, "%s", "machine check");
|
|
|
|
|
sie_page = container_of(vcpu->arch.sie_block,
|
|
|
|
|
struct sie_page, sie_block);
|
|
|
|
|
mcck_info = &sie_page->mcck_info;
|
|
|
|
|
kvm_s390_reinject_machine_check(vcpu, mcck_info);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-19 22:24:28 +08:00
|
|
|
if (vcpu->arch.sie_block->icptcode > 0) {
|
|
|
|
|
int rc = kvm_handle_sie_intercept(vcpu);
|
|
|
|
|
|
|
|
|
|
if (rc != -EOPNOTSUPP)
|
|
|
|
|
return rc;
|
|
|
|
|
vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC;
|
|
|
|
|
vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
|
|
|
|
|
vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
|
|
|
|
|
vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
|
|
|
|
|
return -EREMOTE;
|
|
|
|
|
} else if (exit_reason != -EFAULT) {
|
|
|
|
|
vcpu->stat.exit_null++;
|
|
|
|
|
return 0;
|
2013-09-19 22:26:18 +08:00
|
|
|
} else if (kvm_is_ucontrol(vcpu->kvm)) {
|
|
|
|
|
vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
|
|
|
|
|
vcpu->run->s390_ucontrol.trans_exc_code =
|
|
|
|
|
current->thread.gmap_addr;
|
|
|
|
|
vcpu->run->s390_ucontrol.pgm_code = 0x10;
|
2015-10-19 22:24:28 +08:00
|
|
|
return -EREMOTE;
|
2013-06-17 22:25:18 +08:00
|
|
|
} else if (current->thread.gmap_pfault) {
|
2013-10-07 23:11:48 +08:00
|
|
|
trace_kvm_s390_major_guest_pfault(vcpu);
|
2013-06-17 22:25:18 +08:00
|
|
|
current->thread.gmap_pfault = 0;
|
2015-10-19 22:24:28 +08:00
|
|
|
if (kvm_arch_setup_async_pf(vcpu))
|
|
|
|
|
return 0;
|
|
|
|
|
return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1);
|
2013-09-12 16:33:44 +08:00
|
|
|
}
|
2015-10-19 22:24:28 +08:00
|
|
|
return vcpu_post_run_fault_in_sie(vcpu);
|
2013-09-12 16:33:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __vcpu_run(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
int rc, exit_reason;
|
|
|
|
|
|
2013-09-12 16:33:45 +08:00
|
|
|
/*
|
|
|
|
|
* We try to hold kvm->srcu during most of vcpu_run (except when run-
|
|
|
|
|
* ning the guest), so that memslots (and other stuff) are protected
|
|
|
|
|
*/
|
|
|
|
|
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
|
|
|
|
|
|
2013-09-12 16:33:44 +08:00
|
|
|
do {
|
|
|
|
|
rc = vcpu_pre_run(vcpu);
|
|
|
|
|
if (rc)
|
|
|
|
|
break;
|
2013-09-12 16:33:43 +08:00
|
|
|
|
2013-09-12 16:33:45 +08:00
|
|
|
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
|
2013-09-12 16:33:44 +08:00
|
|
|
/*
|
|
|
|
|
* As PF_VCPU will be used in fault handler, between
|
|
|
|
|
* guest_enter and guest_exit should be no uaccess.
|
|
|
|
|
*/
|
2015-04-30 19:43:30 +08:00
|
|
|
local_irq_disable();
|
2016-06-15 21:18:26 +08:00
|
|
|
guest_enter_irqoff();
|
2016-02-15 16:42:25 +08:00
|
|
|
__disable_cpu_timer_accounting(vcpu);
|
2015-04-30 19:43:30 +08:00
|
|
|
local_irq_enable();
|
2013-09-12 16:33:44 +08:00
|
|
|
exit_reason = sie64a(vcpu->arch.sie_block,
|
|
|
|
|
vcpu->run->s.regs.gprs);
|
2015-04-30 19:43:30 +08:00
|
|
|
local_irq_disable();
|
2016-02-15 16:42:25 +08:00
|
|
|
__enable_cpu_timer_accounting(vcpu);
|
2016-06-15 21:18:26 +08:00
|
|
|
guest_exit_irqoff();
|
2015-04-30 19:43:30 +08:00
|
|
|
local_irq_enable();
|
2013-09-12 16:33:45 +08:00
|
|
|
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
|
2013-09-12 16:33:44 +08:00
|
|
|
|
|
|
|
|
rc = vcpu_post_run(vcpu, exit_reason);
|
2014-01-23 19:26:52 +08:00
|
|
|
} while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
|
2013-09-12 16:33:43 +08:00
|
|
|
|
2013-09-12 16:33:45 +08:00
|
|
|
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
|
2012-01-04 17:25:22 +08:00
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2014-07-17 16:47:43 +08:00
|
|
|
static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
|
|
|
|
|
{
|
2017-02-10 00:15:41 +08:00
|
|
|
struct runtime_instr_cb *riccb;
|
2016-11-29 14:17:55 +08:00
|
|
|
struct gs_cb *gscb;
|
2017-02-10 00:15:41 +08:00
|
|
|
|
|
|
|
|
riccb = (struct runtime_instr_cb *) &kvm_run->s.regs.riccb;
|
2016-11-29 14:17:55 +08:00
|
|
|
gscb = (struct gs_cb *) &kvm_run->s.regs.gscb;
|
2014-07-17 16:47:43 +08:00
|
|
|
vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
|
|
|
|
|
vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
|
|
|
|
|
if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX)
|
|
|
|
|
kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
|
|
|
|
|
if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
|
|
|
|
|
memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
|
2014-07-29 14:53:36 +08:00
|
|
|
/* some control register changes require a tlb flush */
|
|
|
|
|
kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
|
2014-07-17 16:47:43 +08:00
|
|
|
}
|
|
|
|
|
if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) {
|
2016-02-15 16:40:12 +08:00
|
|
|
kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm);
|
2014-07-17 16:47:43 +08:00
|
|
|
vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc;
|
|
|
|
|
vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr;
|
|
|
|
|
vcpu->arch.sie_block->pp = kvm_run->s.regs.pp;
|
|
|
|
|
vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea;
|
|
|
|
|
}
|
|
|
|
|
if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) {
|
|
|
|
|
vcpu->arch.pfault_token = kvm_run->s.regs.pft;
|
|
|
|
|
vcpu->arch.pfault_select = kvm_run->s.regs.pfs;
|
|
|
|
|
vcpu->arch.pfault_compare = kvm_run->s.regs.pfc;
|
2014-10-09 21:01:38 +08:00
|
|
|
if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
|
|
|
|
|
kvm_clear_async_pf_completion_queue(vcpu);
|
2014-07-17 16:47:43 +08:00
|
|
|
}
|
2016-08-15 10:53:22 +08:00
|
|
|
/*
|
|
|
|
|
* If userspace sets the riccb (e.g. after migration) to a valid state,
|
|
|
|
|
* we should enable RI here instead of doing the lazy enablement.
|
|
|
|
|
*/
|
|
|
|
|
if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) &&
|
2017-02-10 00:15:41 +08:00
|
|
|
test_kvm_facility(vcpu->kvm, 64) &&
|
2017-09-14 18:35:45 +08:00
|
|
|
riccb->v &&
|
2017-03-13 18:48:28 +08:00
|
|
|
!(vcpu->arch.sie_block->ecb3 & ECB3_RI)) {
|
2017-02-10 00:15:41 +08:00
|
|
|
VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (sync_regs)");
|
2017-03-13 18:48:28 +08:00
|
|
|
vcpu->arch.sie_block->ecb3 |= ECB3_RI;
|
2016-08-15 10:53:22 +08:00
|
|
|
}
|
2016-11-29 14:17:55 +08:00
|
|
|
/*
|
|
|
|
|
* If userspace sets the gscb (e.g. after migration) to non-zero,
|
|
|
|
|
* we should enable GS here instead of doing the lazy enablement.
|
|
|
|
|
*/
|
|
|
|
|
if ((kvm_run->kvm_dirty_regs & KVM_SYNC_GSCB) &&
|
|
|
|
|
test_kvm_facility(vcpu->kvm, 133) &&
|
|
|
|
|
gscb->gssm &&
|
|
|
|
|
!vcpu->arch.gs_enabled) {
|
|
|
|
|
VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (sync_regs)");
|
|
|
|
|
vcpu->arch.sie_block->ecb |= ECB_GS;
|
|
|
|
|
vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT;
|
|
|
|
|
vcpu->arch.gs_enabled = 1;
|
2016-08-15 10:53:22 +08:00
|
|
|
}
|
2018-01-17 21:44:34 +08:00
|
|
|
if ((kvm_run->kvm_dirty_regs & KVM_SYNC_BPBC) &&
|
|
|
|
|
test_kvm_facility(vcpu->kvm, 82)) {
|
|
|
|
|
vcpu->arch.sie_block->fpf &= ~FPF_BPBC;
|
|
|
|
|
vcpu->arch.sie_block->fpf |= kvm_run->s.regs.bpbc ? FPF_BPBC : 0;
|
|
|
|
|
}
|
2016-11-10 21:22:02 +08:00
|
|
|
save_access_regs(vcpu->arch.host_acrs);
|
|
|
|
|
restore_access_regs(vcpu->run->s.regs.acrs);
|
2016-11-22 16:29:38 +08:00
|
|
|
/* save host (userspace) fprs/vrs */
|
|
|
|
|
save_fpu_regs();
|
|
|
|
|
vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc;
|
|
|
|
|
vcpu->arch.host_fpregs.regs = current->thread.fpu.regs;
|
|
|
|
|
if (MACHINE_HAS_VX)
|
|
|
|
|
current->thread.fpu.regs = vcpu->run->s.regs.vrs;
|
|
|
|
|
else
|
|
|
|
|
current->thread.fpu.regs = vcpu->run->s.regs.fprs;
|
|
|
|
|
current->thread.fpu.fpc = vcpu->run->s.regs.fpc;
|
|
|
|
|
if (test_fp_ctl(current->thread.fpu.fpc))
|
|
|
|
|
/* User space provided an invalid FPC, let's clear it */
|
|
|
|
|
current->thread.fpu.fpc = 0;
|
2016-11-29 14:17:55 +08:00
|
|
|
if (MACHINE_HAS_GS) {
|
|
|
|
|
preempt_disable();
|
|
|
|
|
__ctl_set_bit(2, 4);
|
|
|
|
|
if (current->thread.gs_cb) {
|
|
|
|
|
vcpu->arch.host_gscb = current->thread.gs_cb;
|
|
|
|
|
save_gs_cb(vcpu->arch.host_gscb);
|
|
|
|
|
}
|
|
|
|
|
if (vcpu->arch.gs_enabled) {
|
|
|
|
|
current->thread.gs_cb = (struct gs_cb *)
|
|
|
|
|
&vcpu->run->s.regs.gscb;
|
|
|
|
|
restore_gs_cb(current->thread.gs_cb);
|
|
|
|
|
}
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
2018-03-09 00:08:49 +08:00
|
|
|
/* SIE will load etoken directly from SDNX and therefore kvm_run */
|
2016-08-15 10:53:22 +08:00
|
|
|
|
2014-07-17 16:47:43 +08:00
|
|
|
kvm_run->kvm_dirty_regs = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
|
|
|
|
|
{
|
|
|
|
|
kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
|
|
|
|
|
kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
|
|
|
|
|
kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu);
|
|
|
|
|
memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
|
2016-02-15 16:40:12 +08:00
|
|
|
kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu);
|
2014-07-17 16:47:43 +08:00
|
|
|
kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc;
|
|
|
|
|
kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr;
|
|
|
|
|
kvm_run->s.regs.pp = vcpu->arch.sie_block->pp;
|
|
|
|
|
kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea;
|
|
|
|
|
kvm_run->s.regs.pft = vcpu->arch.pfault_token;
|
|
|
|
|
kvm_run->s.regs.pfs = vcpu->arch.pfault_select;
|
|
|
|
|
kvm_run->s.regs.pfc = vcpu->arch.pfault_compare;
|
2018-01-17 21:44:34 +08:00
|
|
|
kvm_run->s.regs.bpbc = (vcpu->arch.sie_block->fpf & FPF_BPBC) == FPF_BPBC;
|
2016-11-10 21:22:02 +08:00
|
|
|
save_access_regs(vcpu->run->s.regs.acrs);
|
|
|
|
|
restore_access_regs(vcpu->arch.host_acrs);
|
2016-11-22 16:29:38 +08:00
|
|
|
/* Save guest register state */
|
|
|
|
|
save_fpu_regs();
|
|
|
|
|
vcpu->run->s.regs.fpc = current->thread.fpu.fpc;
|
|
|
|
|
/* Restore will be done lazily at return */
|
|
|
|
|
current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc;
|
|
|
|
|
current->thread.fpu.regs = vcpu->arch.host_fpregs.regs;
|
2016-11-29 14:17:55 +08:00
|
|
|
if (MACHINE_HAS_GS) {
|
|
|
|
|
__ctl_set_bit(2, 4);
|
|
|
|
|
if (vcpu->arch.gs_enabled)
|
|
|
|
|
save_gs_cb(current->thread.gs_cb);
|
|
|
|
|
preempt_disable();
|
|
|
|
|
current->thread.gs_cb = vcpu->arch.host_gscb;
|
|
|
|
|
restore_gs_cb(vcpu->arch.host_gscb);
|
|
|
|
|
preempt_enable();
|
|
|
|
|
if (!vcpu->arch.host_gscb)
|
|
|
|
|
__ctl_clear_bit(2, 4);
|
|
|
|
|
vcpu->arch.host_gscb = NULL;
|
|
|
|
|
}
|
2018-03-09 00:08:49 +08:00
|
|
|
/* SIE will save etoken directly into SDNX and therefore kvm_run */
|
2014-07-17 16:47:43 +08:00
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
|
|
|
|
|
{
|
2008-03-26 01:47:23 +08:00
|
|
|
int rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2017-02-08 18:50:15 +08:00
|
|
|
if (kvm_run->immediate_exit)
|
|
|
|
|
return -EINTR;
|
|
|
|
|
|
2017-12-05 04:35:25 +08:00
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
if (guestdbg_exit_pending(vcpu)) {
|
|
|
|
|
kvm_s390_prepare_debug_exit(vcpu);
|
2017-12-05 04:35:25 +08:00
|
|
|
rc = 0;
|
|
|
|
|
goto out;
|
2014-01-23 19:26:52 +08:00
|
|
|
}
|
|
|
|
|
|
2017-11-25 05:39:01 +08:00
|
|
|
kvm_sigset_activate(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2014-04-10 23:35:00 +08:00
|
|
|
if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) {
|
|
|
|
|
kvm_s390_vcpu_start(vcpu);
|
|
|
|
|
} else if (is_vcpu_stopped(vcpu)) {
|
2015-05-20 19:24:02 +08:00
|
|
|
pr_err_ratelimited("can't run stopped vcpu %d\n",
|
2014-04-10 23:35:00 +08:00
|
|
|
vcpu->vcpu_id);
|
2017-12-05 04:35:25 +08:00
|
|
|
rc = -EINVAL;
|
|
|
|
|
goto out;
|
2014-04-10 23:35:00 +08:00
|
|
|
}
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2014-07-17 16:47:43 +08:00
|
|
|
sync_regs(vcpu, kvm_run);
|
2016-02-15 16:42:25 +08:00
|
|
|
enable_cpu_timer_accounting(vcpu);
|
2009-11-19 21:21:16 +08:00
|
|
|
|
2009-06-12 16:26:32 +08:00
|
|
|
might_fault();
|
2013-09-12 16:33:44 +08:00
|
|
|
rc = __vcpu_run(vcpu);
|
2009-05-20 21:34:55 +08:00
|
|
|
|
2009-05-20 21:34:56 +08:00
|
|
|
if (signal_pending(current) && !rc) {
|
|
|
|
|
kvm_run->exit_reason = KVM_EXIT_INTR;
|
2008-03-26 01:47:23 +08:00
|
|
|
rc = -EINTR;
|
2009-05-20 21:34:56 +08:00
|
|
|
}
|
2008-03-26 01:47:23 +08:00
|
|
|
|
2014-01-23 19:26:52 +08:00
|
|
|
if (guestdbg_exit_pending(vcpu) && !rc) {
|
|
|
|
|
kvm_s390_prepare_debug_exit(vcpu);
|
|
|
|
|
rc = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:23 +08:00
|
|
|
if (rc == -EREMOTE) {
|
2015-10-19 22:24:28 +08:00
|
|
|
/* userspace support is needed, kvm_run has been prepared */
|
2008-03-26 01:47:23 +08:00
|
|
|
rc = 0;
|
|
|
|
|
}
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2016-02-15 16:42:25 +08:00
|
|
|
disable_cpu_timer_accounting(vcpu);
|
2014-07-17 16:47:43 +08:00
|
|
|
store_regs(vcpu, kvm_run);
|
2009-11-19 21:21:16 +08:00
|
|
|
|
2017-11-25 05:39:01 +08:00
|
|
|
kvm_sigset_deactivate(vcpu);
|
2008-03-26 01:47:20 +08:00
|
|
|
|
|
|
|
|
vcpu->stat.exit_userspace++;
|
2017-12-05 04:35:25 +08:00
|
|
|
out:
|
|
|
|
|
vcpu_put(vcpu);
|
2008-04-04 21:12:35 +08:00
|
|
|
return rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* store status at address
|
|
|
|
|
* we use have two special cases:
|
|
|
|
|
* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
|
|
|
|
|
* KVM_S390_STORE_STATUS_PREFIXED: -> prefix
|
|
|
|
|
*/
|
2014-01-01 23:45:58 +08:00
|
|
|
int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2011-07-24 16:48:22 +08:00
|
|
|
unsigned char archmode = 1;
|
2016-01-15 05:12:47 +08:00
|
|
|
freg_t fprs[NUM_FPRS];
|
2014-05-13 22:58:30 +08:00
|
|
|
unsigned int px;
|
2016-02-15 16:40:12 +08:00
|
|
|
u64 clkcomp, cputm;
|
2014-01-01 23:45:58 +08:00
|
|
|
int rc;
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2015-10-23 15:02:32 +08:00
|
|
|
px = kvm_s390_get_prefix(vcpu);
|
2014-01-01 23:45:58 +08:00
|
|
|
if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
|
|
|
|
|
if (write_guest_abs(vcpu, 163, &archmode, 1))
|
2008-03-26 01:47:20 +08:00
|
|
|
return -EFAULT;
|
2015-10-23 15:02:32 +08:00
|
|
|
gpa = 0;
|
2014-01-01 23:45:58 +08:00
|
|
|
} else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
|
|
|
|
|
if (write_guest_real(vcpu, 163, &archmode, 1))
|
2008-03-26 01:47:20 +08:00
|
|
|
return -EFAULT;
|
2015-10-23 15:02:32 +08:00
|
|
|
gpa = px;
|
|
|
|
|
} else
|
|
|
|
|
gpa -= __LC_FPREGS_SAVE_AREA;
|
2016-01-15 05:12:47 +08:00
|
|
|
|
|
|
|
|
/* manually convert vector registers if necessary */
|
|
|
|
|
if (MACHINE_HAS_VX) {
|
2016-03-08 19:24:30 +08:00
|
|
|
convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs);
|
2016-01-15 05:12:47 +08:00
|
|
|
rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA,
|
|
|
|
|
fprs, 128);
|
|
|
|
|
} else {
|
|
|
|
|
rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA,
|
2016-01-18 21:46:34 +08:00
|
|
|
vcpu->run->s.regs.fprs, 128);
|
2016-01-15 05:12:47 +08:00
|
|
|
}
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
vcpu->run->s.regs.gprs, 128);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
&vcpu->arch.sie_block->gpsw, 16);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA,
|
2014-05-13 22:58:30 +08:00
|
|
|
&px, 4);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA,
|
2016-01-15 05:12:47 +08:00
|
|
|
&vcpu->run->s.regs.fpc, 4);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
&vcpu->arch.sie_block->todpr, 4);
|
2016-02-15 16:40:12 +08:00
|
|
|
cputm = kvm_s390_get_cpu_timer(vcpu);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA,
|
2016-02-15 16:40:12 +08:00
|
|
|
&cputm, 8);
|
2013-11-14 03:28:18 +08:00
|
|
|
clkcomp = vcpu->arch.sie_block->ckc >> 8;
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
&clkcomp, 8);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
&vcpu->run->s.regs.acrs, 64);
|
2015-10-23 15:02:32 +08:00
|
|
|
rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA,
|
2014-01-01 23:45:58 +08:00
|
|
|
&vcpu->arch.sie_block->gcr, 128);
|
|
|
|
|
return rc ? -EFAULT : 0;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2013-11-06 22:46:33 +08:00
|
|
|
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
|
2016-11-10 21:22:02 +08:00
|
|
|
* switch in the run ioctl. Let's update our copies before we save
|
2013-11-06 22:46:33 +08:00
|
|
|
* it into the save area
|
|
|
|
|
*/
|
2015-06-29 22:43:06 +08:00
|
|
|
save_fpu_regs();
|
2016-01-15 05:12:47 +08:00
|
|
|
vcpu->run->s.regs.fpc = current->thread.fpu.fpc;
|
2013-11-06 22:46:33 +08:00
|
|
|
save_access_regs(vcpu->run->s.regs.acrs);
|
|
|
|
|
|
|
|
|
|
return kvm_s390_store_status_unloaded(vcpu, addr);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-14 18:00:21 +08:00
|
|
|
static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
|
2015-04-09 19:49:04 +08:00
|
|
|
kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu);
|
2014-03-14 18:00:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
|
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
|
|
|
__disable_ibs_on_vcpu(vcpu);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-04-04 21:57:08 +08:00
|
|
|
if (!sclp.has_ibs)
|
|
|
|
|
return;
|
2014-03-14 18:00:21 +08:00
|
|
|
kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
|
2015-04-09 19:49:04 +08:00
|
|
|
kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu);
|
2014-03-14 18:00:21 +08:00
|
|
|
}
|
|
|
|
|
|
2014-03-14 17:59:29 +08:00
|
|
|
void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2014-03-14 18:00:21 +08:00
|
|
|
int i, online_vcpus, started_vcpus = 0;
|
|
|
|
|
|
|
|
|
|
if (!is_vcpu_stopped(vcpu))
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-14 17:59:29 +08:00
|
|
|
trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
|
2014-03-14 18:00:21 +08:00
|
|
|
/* Only one cpu at a time may enter/leave the STOPPED state. */
|
2014-05-06 22:11:14 +08:00
|
|
|
spin_lock(&vcpu->kvm->arch.start_stop_lock);
|
2014-03-14 18:00:21 +08:00
|
|
|
online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < online_vcpus; i++) {
|
|
|
|
|
if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
|
|
|
|
|
started_vcpus++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (started_vcpus == 0) {
|
|
|
|
|
/* we're the only active VCPU -> speed it up */
|
|
|
|
|
__enable_ibs_on_vcpu(vcpu);
|
|
|
|
|
} else if (started_vcpus == 1) {
|
|
|
|
|
/*
|
|
|
|
|
* As we are starting a second VCPU, we have to disable
|
|
|
|
|
* the IBS facility on all VCPUs to remove potentially
|
|
|
|
|
* oustanding ENABLE requests.
|
|
|
|
|
*/
|
|
|
|
|
__disable_ibs_on_all_vcpus(vcpu->kvm);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-24 01:05:30 +08:00
|
|
|
kvm_s390_clear_cpuflags(vcpu, CPUSTAT_STOPPED);
|
2014-03-14 18:00:21 +08:00
|
|
|
/*
|
|
|
|
|
* Another VCPU might have used IBS while we were offline.
|
|
|
|
|
* Let's play safe and flush the VCPU at startup.
|
|
|
|
|
*/
|
2014-07-29 14:53:36 +08:00
|
|
|
kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
|
2014-05-06 22:11:14 +08:00
|
|
|
spin_unlock(&vcpu->kvm->arch.start_stop_lock);
|
2014-03-14 18:00:21 +08:00
|
|
|
return;
|
2014-03-14 17:59:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2014-03-14 18:00:21 +08:00
|
|
|
int i, online_vcpus, started_vcpus = 0;
|
|
|
|
|
struct kvm_vcpu *started_vcpu = NULL;
|
|
|
|
|
|
|
|
|
|
if (is_vcpu_stopped(vcpu))
|
|
|
|
|
return;
|
|
|
|
|
|
2014-03-14 17:59:29 +08:00
|
|
|
trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
|
2014-03-14 18:00:21 +08:00
|
|
|
/* Only one cpu at a time may enter/leave the STOPPED state. */
|
2014-05-06 22:11:14 +08:00
|
|
|
spin_lock(&vcpu->kvm->arch.start_stop_lock);
|
2014-03-14 18:00:21 +08:00
|
|
|
online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
|
|
|
|
|
|
2014-04-14 18:40:03 +08:00
|
|
|
/* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
|
2014-10-15 22:48:53 +08:00
|
|
|
kvm_s390_clear_stop_irq(vcpu);
|
2014-04-14 18:40:03 +08:00
|
|
|
|
2018-01-24 01:05:29 +08:00
|
|
|
kvm_s390_set_cpuflags(vcpu, CPUSTAT_STOPPED);
|
2014-03-14 18:00:21 +08:00
|
|
|
__disable_ibs_on_vcpu(vcpu);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < online_vcpus; i++) {
|
|
|
|
|
if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
|
|
|
|
|
started_vcpus++;
|
|
|
|
|
started_vcpu = vcpu->kvm->vcpus[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (started_vcpus == 1) {
|
|
|
|
|
/*
|
|
|
|
|
* As we only have one VCPU left, we want to enable the
|
|
|
|
|
* IBS facility for that VCPU to speed it up.
|
|
|
|
|
*/
|
|
|
|
|
__enable_ibs_on_vcpu(started_vcpu);
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-06 22:11:14 +08:00
|
|
|
spin_unlock(&vcpu->kvm->arch.start_stop_lock);
|
2014-03-14 18:00:21 +08:00
|
|
|
return;
|
2014-03-14 17:59:29 +08:00
|
|
|
}
|
|
|
|
|
|
2012-12-20 22:32:11 +08:00
|
|
|
static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_enable_cap *cap)
|
|
|
|
|
{
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
if (cap->flags)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
switch (cap->cap) {
|
2012-12-20 22:32:12 +08:00
|
|
|
case KVM_CAP_S390_CSS_SUPPORT:
|
|
|
|
|
if (!vcpu->kvm->arch.css_support) {
|
|
|
|
|
vcpu->kvm->arch.css_support = 1;
|
2015-07-22 21:52:10 +08:00
|
|
|
VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support");
|
2012-12-20 22:32:12 +08:00
|
|
|
trace_kvm_s390_enable_css(vcpu->kvm);
|
|
|
|
|
}
|
|
|
|
|
r = 0;
|
|
|
|
|
break;
|
2012-12-20 22:32:11 +08:00
|
|
|
default:
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-06 22:01:21 +08:00
|
|
|
static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_s390_mem_op *mop)
|
|
|
|
|
{
|
|
|
|
|
void __user *uaddr = (void __user *)mop->buf;
|
|
|
|
|
void *tmpbuf = NULL;
|
|
|
|
|
int r, srcu_idx;
|
|
|
|
|
const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION
|
|
|
|
|
| KVM_S390_MEMOP_F_CHECK_ONLY;
|
|
|
|
|
|
|
|
|
|
if (mop->flags & ~supported_flags)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
if (mop->size > MEM_OP_MAX_SIZE)
|
|
|
|
|
return -E2BIG;
|
|
|
|
|
|
|
|
|
|
if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) {
|
|
|
|
|
tmpbuf = vmalloc(mop->size);
|
|
|
|
|
if (!tmpbuf)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
|
|
|
|
|
|
|
|
|
|
switch (mop->op) {
|
|
|
|
|
case KVM_S390_MEMOP_LOGICAL_READ:
|
|
|
|
|
if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) {
|
2015-11-16 22:42:11 +08:00
|
|
|
r = check_gva_range(vcpu, mop->gaddr, mop->ar,
|
|
|
|
|
mop->size, GACC_FETCH);
|
2015-02-06 22:01:21 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);
|
|
|
|
|
if (r == 0) {
|
|
|
|
|
if (copy_to_user(uaddr, tmpbuf, mop->size))
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case KVM_S390_MEMOP_LOGICAL_WRITE:
|
|
|
|
|
if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) {
|
2015-11-16 22:42:11 +08:00
|
|
|
r = check_gva_range(vcpu, mop->gaddr, mop->ar,
|
|
|
|
|
mop->size, GACC_STORE);
|
2015-02-06 22:01:21 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (copy_from_user(tmpbuf, uaddr, mop->size)) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx);
|
|
|
|
|
|
|
|
|
|
if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0)
|
|
|
|
|
kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
|
|
|
|
|
|
|
|
|
|
vfree(tmpbuf);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-13 00:41:34 +08:00
|
|
|
long kvm_arch_vcpu_async_ioctl(struct file *filp,
|
|
|
|
|
unsigned int ioctl, unsigned long arg)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu = filp->private_data;
|
|
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
|
|
2010-05-13 17:35:17 +08:00
|
|
|
switch (ioctl) {
|
2014-11-12 03:57:06 +08:00
|
|
|
case KVM_S390_IRQ: {
|
|
|
|
|
struct kvm_s390_irq s390irq;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&s390irq, argp, sizeof(s390irq)))
|
2017-12-05 04:35:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
|
return kvm_s390_inject_vcpu(vcpu, &s390irq);
|
2014-11-12 03:57:06 +08:00
|
|
|
}
|
2010-05-13 17:35:17 +08:00
|
|
|
case KVM_S390_INTERRUPT: {
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
struct kvm_s390_interrupt s390int;
|
2014-07-29 21:11:49 +08:00
|
|
|
struct kvm_s390_irq s390irq;
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
|
|
|
|
|
if (copy_from_user(&s390int, argp, sizeof(s390int)))
|
2017-12-05 04:35:36 +08:00
|
|
|
return -EFAULT;
|
2014-07-29 21:11:49 +08:00
|
|
|
if (s390int_to_s390irq(&s390int, &s390irq))
|
|
|
|
|
return -EINVAL;
|
2017-12-05 04:35:36 +08:00
|
|
|
return kvm_s390_inject_vcpu(vcpu, &s390irq);
|
KVM: s390: interrupt subsystem, cpu timer, waitpsw
This patch contains the s390 interrupt subsystem (similar to in kernel apic)
including timer interrupts (similar to in-kernel-pit) and enabled wait
(similar to in kernel hlt).
In order to achieve that, this patch also introduces intercept handling
for instruction intercepts, and it implements load control instructions.
This patch introduces an ioctl KVM_S390_INTERRUPT which is valid for both
the vm file descriptors and the vcpu file descriptors. In case this ioctl is
issued against a vm file descriptor, the interrupt is considered floating.
Floating interrupts may be delivered to any virtual cpu in the configuration.
The following interrupts are supported:
SIGP STOP - interprocessor signal that stops a remote cpu
SIGP SET PREFIX - interprocessor signal that sets the prefix register of a
(stopped) remote cpu
INT EMERGENCY - interprocessor interrupt, usually used to signal need_reshed
and for smp_call_function() in the guest.
PROGRAM INT - exception during program execution such as page fault, illegal
instruction and friends
RESTART - interprocessor signal that starts a stopped cpu
INT VIRTIO - floating interrupt for virtio signalisation
INT SERVICE - floating interrupt for signalisations from the system
service processor
struct kvm_s390_interrupt, which is submitted as ioctl parameter when injecting
an interrupt, also carrys parameter data for interrupts along with the interrupt
type. Interrupts on s390 usually have a state that represents the current
operation, or identifies which device has caused the interruption on s390.
kvm_s390_handle_wait() does handle waitpsw in two flavors: in case of a
disabled wait (that is, disabled for interrupts), we exit to userspace. In case
of an enabled wait we set up a timer that equals the cpu clock comparator value
and sleep on a wait queue.
[christian: change virtio interrupt to 0x2603]
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Carsten Otte <cotte@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-03-26 01:47:26 +08:00
|
|
|
}
|
2017-12-05 04:35:36 +08:00
|
|
|
}
|
2017-12-13 00:41:34 +08:00
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
long kvm_arch_vcpu_ioctl(struct file *filp,
|
|
|
|
|
unsigned int ioctl, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_vcpu *vcpu = filp->private_data;
|
|
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
|
int idx;
|
|
|
|
|
long r;
|
2017-12-05 04:35:36 +08:00
|
|
|
|
|
|
|
|
vcpu_load(vcpu);
|
|
|
|
|
|
|
|
|
|
switch (ioctl) {
|
2008-03-26 01:47:20 +08:00
|
|
|
case KVM_S390_STORE_STATUS:
|
2013-09-12 16:33:45 +08:00
|
|
|
idx = srcu_read_lock(&vcpu->kvm->srcu);
|
2010-05-13 17:21:46 +08:00
|
|
|
r = kvm_s390_vcpu_store_status(vcpu, arg);
|
2013-09-12 16:33:45 +08:00
|
|
|
srcu_read_unlock(&vcpu->kvm->srcu, idx);
|
2010-05-13 17:21:46 +08:00
|
|
|
break;
|
2008-03-26 01:47:20 +08:00
|
|
|
case KVM_S390_SET_INITIAL_PSW: {
|
|
|
|
|
psw_t psw;
|
|
|
|
|
|
2010-05-13 17:21:46 +08:00
|
|
|
r = -EFAULT;
|
2008-03-26 01:47:20 +08:00
|
|
|
if (copy_from_user(&psw, argp, sizeof(psw)))
|
2010-05-13 17:21:46 +08:00
|
|
|
break;
|
|
|
|
|
r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
|
|
|
|
|
break;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
case KVM_S390_INITIAL_RESET:
|
2010-05-13 17:21:46 +08:00
|
|
|
r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
|
|
|
|
|
break;
|
2012-05-15 20:15:26 +08:00
|
|
|
case KVM_SET_ONE_REG:
|
|
|
|
|
case KVM_GET_ONE_REG: {
|
|
|
|
|
struct kvm_one_reg reg;
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(®, argp, sizeof(reg)))
|
|
|
|
|
break;
|
|
|
|
|
if (ioctl == KVM_SET_ONE_REG)
|
|
|
|
|
r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®);
|
|
|
|
|
else
|
|
|
|
|
r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-01-04 17:25:21 +08:00
|
|
|
#ifdef CONFIG_KVM_S390_UCONTROL
|
|
|
|
|
case KVM_S390_UCAS_MAP: {
|
|
|
|
|
struct kvm_s390_ucas_mapping ucasmap;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!kvm_is_ucontrol(vcpu->kvm)) {
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
|
|
|
|
|
ucasmap.vcpu_addr, ucasmap.length);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_S390_UCAS_UNMAP: {
|
|
|
|
|
struct kvm_s390_ucas_mapping ucasmap;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!kvm_is_ucontrol(vcpu->kvm)) {
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
|
|
|
|
|
ucasmap.length);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2012-01-04 17:25:26 +08:00
|
|
|
case KVM_S390_VCPU_FAULT: {
|
2014-04-30 22:04:25 +08:00
|
|
|
r = gmap_fault(vcpu->arch.gmap, arg, 0);
|
2012-01-04 17:25:26 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2012-12-20 22:32:11 +08:00
|
|
|
case KVM_ENABLE_CAP:
|
|
|
|
|
{
|
|
|
|
|
struct kvm_enable_cap cap;
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&cap, argp, sizeof(cap)))
|
|
|
|
|
break;
|
|
|
|
|
r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2015-02-06 22:01:21 +08:00
|
|
|
case KVM_S390_MEM_OP: {
|
|
|
|
|
struct kvm_s390_mem_op mem_op;
|
|
|
|
|
|
|
|
|
|
if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0)
|
|
|
|
|
r = kvm_s390_guest_mem_op(vcpu, &mem_op);
|
|
|
|
|
else
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-11-25 00:13:46 +08:00
|
|
|
case KVM_S390_SET_IRQ_STATE: {
|
|
|
|
|
struct kvm_s390_irq_state irq_state;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&irq_state, argp, sizeof(irq_state)))
|
|
|
|
|
break;
|
|
|
|
|
if (irq_state.len > VCPU_IRQS_MAX_BUF ||
|
|
|
|
|
irq_state.len == 0 ||
|
|
|
|
|
irq_state.len % sizeof(struct kvm_s390_irq) > 0) {
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2017-11-21 23:02:52 +08:00
|
|
|
/* do not use irq_state.flags, it will break old QEMUs */
|
2014-11-25 00:13:46 +08:00
|
|
|
r = kvm_s390_set_irq_state(vcpu,
|
|
|
|
|
(void __user *) irq_state.buf,
|
|
|
|
|
irq_state.len);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case KVM_S390_GET_IRQ_STATE: {
|
|
|
|
|
struct kvm_s390_irq_state irq_state;
|
|
|
|
|
|
|
|
|
|
r = -EFAULT;
|
|
|
|
|
if (copy_from_user(&irq_state, argp, sizeof(irq_state)))
|
|
|
|
|
break;
|
|
|
|
|
if (irq_state.len == 0) {
|
|
|
|
|
r = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2017-11-21 23:02:52 +08:00
|
|
|
/* do not use irq_state.flags, it will break old QEMUs */
|
2014-11-25 00:13:46 +08:00
|
|
|
r = kvm_s390_get_irq_state(vcpu,
|
|
|
|
|
(__u8 __user *) irq_state.buf,
|
|
|
|
|
irq_state.len);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2008-03-26 01:47:20 +08:00
|
|
|
default:
|
2012-01-04 17:25:30 +08:00
|
|
|
r = -ENOTTY;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
2017-12-05 04:35:36 +08:00
|
|
|
|
|
|
|
|
vcpu_put(vcpu);
|
2010-05-13 17:21:46 +08:00
|
|
|
return r;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-19 03:19:58 +08:00
|
|
|
vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
|
2012-01-04 17:25:23 +08:00
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_KVM_S390_UCONTROL
|
|
|
|
|
if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
|
|
|
|
|
&& (kvm_is_ucontrol(vcpu->kvm))) {
|
|
|
|
|
vmf->page = virt_to_page(vcpu->arch.sie_block);
|
|
|
|
|
get_page(vmf->page);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return VM_FAULT_SIGBUS;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-08 00:48:00 +08:00
|
|
|
int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
|
|
|
|
|
unsigned long npages)
|
2012-02-08 12:02:18 +08:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
/* Section: memory related */
|
2009-12-24 00:35:18 +08:00
|
|
|
int kvm_arch_prepare_memory_region(struct kvm *kvm,
|
|
|
|
|
struct kvm_memory_slot *memslot,
|
2015-05-18 19:59:39 +08:00
|
|
|
const struct kvm_userspace_memory_region *mem,
|
2013-02-27 18:44:34 +08:00
|
|
|
enum kvm_mr_change change)
|
2008-03-26 01:47:20 +08:00
|
|
|
{
|
2013-03-26 00:22:57 +08:00
|
|
|
/* A few sanity checks. We can have memory slots which have to be
|
|
|
|
|
located/ended at a segment boundary (1MB). The memory in userland is
|
|
|
|
|
ok to be fragmented into various different vmas. It is okay to mmap()
|
|
|
|
|
and munmap() stuff in this slot after doing this call at any time */
|
2008-03-26 01:47:20 +08:00
|
|
|
|
2011-07-24 16:48:21 +08:00
|
|
|
if (mem->userspace_addr & 0xffffful)
|
2008-03-26 01:47:20 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-07-24 16:48:21 +08:00
|
|
|
if (mem->memory_size & 0xffffful)
|
2008-03-26 01:47:20 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-12-02 00:24:42 +08:00
|
|
|
if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2009-12-24 00:35:18 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvm_arch_commit_memory_region(struct kvm *kvm,
|
2015-05-18 19:59:39 +08:00
|
|
|
const struct kvm_userspace_memory_region *mem,
|
2013-02-27 18:45:25 +08:00
|
|
|
const struct kvm_memory_slot *old,
|
2015-05-18 19:20:23 +08:00
|
|
|
const struct kvm_memory_slot *new,
|
2013-02-27 18:45:25 +08:00
|
|
|
enum kvm_mr_change change)
|
2009-12-24 00:35:18 +08:00
|
|
|
{
|
2011-07-24 16:48:23 +08:00
|
|
|
int rc;
|
2009-12-24 00:35:18 +08:00
|
|
|
|
2013-03-26 00:22:48 +08:00
|
|
|
/* If the basics of the memslot do not change, we do not want
|
|
|
|
|
* to update the gmap. Every update causes several unnecessary
|
|
|
|
|
* segment translation exceptions. This is usually handled just
|
|
|
|
|
* fine by the normal fault handler + gmap, but it will also
|
|
|
|
|
* cause faults on the prefix page of running guest CPUs.
|
|
|
|
|
*/
|
|
|
|
|
if (old->userspace_addr == mem->userspace_addr &&
|
|
|
|
|
old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
|
|
|
|
|
old->npages * PAGE_SIZE == mem->memory_size)
|
|
|
|
|
return;
|
2011-07-24 16:48:21 +08:00
|
|
|
|
|
|
|
|
rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
|
|
|
|
|
mem->guest_phys_addr, mem->memory_size);
|
|
|
|
|
if (rc)
|
2015-05-20 19:24:02 +08:00
|
|
|
pr_warn("failed to commit memory region\n");
|
2011-07-24 16:48:21 +08:00
|
|
|
return;
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
2016-04-01 20:38:57 +08:00
|
|
|
static inline unsigned long nonhyp_mask(int i)
|
|
|
|
|
{
|
|
|
|
|
unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30;
|
|
|
|
|
|
|
|
|
|
return 0x0000ffffffffffffUL >> (nonhyp_fai << 4);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-13 18:16:35 +08:00
|
|
|
void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
vcpu->valid_wakeup = false;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-26 01:47:20 +08:00
|
|
|
static int __init kvm_s390_init(void)
|
|
|
|
|
{
|
2016-04-01 20:38:57 +08:00
|
|
|
int i;
|
|
|
|
|
|
2015-01-30 23:01:38 +08:00
|
|
|
if (!sclp.has_sief2) {
|
2018-12-10 18:15:16 +08:00
|
|
|
pr_info("SIE is not available\n");
|
2015-01-30 23:01:38 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-13 18:28:31 +08:00
|
|
|
if (nested && hpage) {
|
2018-12-10 18:15:16 +08:00
|
|
|
pr_info("A KVM host that supports nesting cannot back its KVM guests with huge pages\n");
|
2018-07-13 18:28:31 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-01 20:38:57 +08:00
|
|
|
for (i = 0; i < 16; i++)
|
2018-02-10 00:26:29 +08:00
|
|
|
kvm_s390_fac_base[i] |=
|
2016-04-01 20:38:57 +08:00
|
|
|
S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i);
|
|
|
|
|
|
2015-02-02 22:42:51 +08:00
|
|
|
return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
|
2008-03-26 01:47:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit kvm_s390_exit(void)
|
|
|
|
|
{
|
|
|
|
|
kvm_exit();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(kvm_s390_init);
|
|
|
|
|
module_exit(kvm_s390_exit);
|
2013-05-28 00:42:33 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Enable autoloading of the kvm module.
|
|
|
|
|
* Note that we add the module alias here instead of virt/kvm/kvm_main.c
|
|
|
|
|
* since x86 takes a different approach.
|
|
|
|
|
*/
|
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
|
MODULE_ALIAS_MISCDEV(KVM_MINOR);
|
|
|
|
|
MODULE_ALIAS("devname:kvm");
|