mirror of
https://github.com/torvalds/linux.git
synced 2024-11-24 13:11:40 +00:00
KVM: s390: Fixes and features for kvm/next (4.3)
1. Rework logging infrastructure (s390dbf) to integrate feedback learned
when debugging performance and test issues
2. Some cleanups and simplifications for CMMA handling
3. Fix gdb debugging and single stepping on some instructions
4. Error handling for storage key setup
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.14 (GNU/Linux)
iQIcBAABAgAGBQJVuJbjAAoJEBF7vIC1phx8ky0QAImmDTvU4D1QNJyyHn6OZ1v8
DogjNTGpeGXxfq6aMPJDn7kkSo2hubZ57ZUsd70k1i/77EMNcjzjSTn82GAAQZPC
kBPHTMoOV0tp6J8/uTfadhYWQNzh+yqBP8L+4yHbyo8Ro/poLABeTBk9Ojcqjpb8
mdthZYvOzfsthd74Giva1ttqxrIYc9D1S2wzWUv/eFg6gpBg7TKJlt1DAltiP1x6
arfqB9rmX2yqYniXWVW2HrQK6VP3yC2hFGo5nbehlBtmY7wkQj8Ab5g7vtHtvmGX
BENAMgIew3IeJSbqxACFub8J6FhYndzo6X5CnrUweYq8DscW2u2DrJQLTuKie9xt
7V9nu2jqJ7emx0lnemXIdgc96cEyubh5Dy2ZmW1zqV2jM4I8O86NgsRgeBpc86ES
TOvErgaLOxEZwP6T89citQRcyZNPGlbiQVFAmNSvJpEcjo/ltd+/R2mEYjbm3JE4
hvF19Z6JQ1VaePqQZAuXNcQekiCK3ewNZER0ckc2PLJ9K/tLRl/R1Ymhgf82yXxh
ClTNgd+R+JQopxlRstNvZypEuJae2RPqPTlper3FLIu4k7Ugu3+Hg9FlEpj8kcI6
P8RO95sRBvdR7I6EMiNM/gBBOG5ocH5spG4xrc87AfyJQq+E3RK8DBpXQevK8Aio
gopinQ4eSlQwKF82v624
=rp6s
-----END PGP SIGNATURE-----
Merge tag 'kvm-s390-next-20150728' of git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux into kvm-next
KVM: s390: Fixes and features for kvm/next (4.3)
1. Rework logging infrastructure (s390dbf) to integrate feedback learned
when debugging performance and test issues
2. Some cleanups and simplifications for CMMA handling
3. Fix gdb debugging and single stepping on some instructions
4. Error handling for storage key setup
This commit is contained in:
Paolo Bonzini
commit
554726d33c
@ -16,8 +16,6 @@ Debugging390.txt
|
||||
- hints for debugging on s390 systems.
|
||||
driver-model.txt
|
||||
- information on s390 devices and the driver model.
|
||||
kvm.txt
|
||||
- ioctl calls to /dev/kvm on s390.
|
||||
monreader.txt
|
||||
- information on accessing the z/VM monitor stream from Linux.
|
||||
qeth.txt
|
||||
|
||||
@ -1,125 +0,0 @@
|
||||
*** BIG FAT WARNING ***
|
||||
The kvm module is currently in EXPERIMENTAL state for s390. This means that
|
||||
the interface to the module is not yet considered to remain stable. Thus, be
|
||||
prepared that we keep breaking your userspace application and guest
|
||||
compatibility over and over again until we feel happy with the result. Make sure
|
||||
your guest kernel, your host kernel, and your userspace launcher are in a
|
||||
consistent state.
|
||||
|
||||
This Documentation describes the unique ioctl calls to /dev/kvm, the resulting
|
||||
kvm-vm file descriptors, and the kvm-vcpu file descriptors that differ from x86.
|
||||
|
||||
1. ioctl calls to /dev/kvm
|
||||
KVM does support the following ioctls on s390 that are common with other
|
||||
architectures and do behave the same:
|
||||
KVM_GET_API_VERSION
|
||||
KVM_CREATE_VM (*) see note
|
||||
KVM_CHECK_EXTENSION
|
||||
KVM_GET_VCPU_MMAP_SIZE
|
||||
|
||||
Notes:
|
||||
* KVM_CREATE_VM may fail on s390, if the calling process has multiple
|
||||
threads and has not called KVM_S390_ENABLE_SIE before.
|
||||
|
||||
In addition, on s390 the following architecture specific ioctls are supported:
|
||||
ioctl: KVM_S390_ENABLE_SIE
|
||||
args: none
|
||||
see also: include/linux/kvm.h
|
||||
This call causes the kernel to switch on PGSTE in the user page table. This
|
||||
operation is needed in order to run a virtual machine, and it requires the
|
||||
calling process to be single-threaded. Note that the first call to KVM_CREATE_VM
|
||||
will implicitly try to switch on PGSTE if the user process has not called
|
||||
KVM_S390_ENABLE_SIE before. User processes that want to launch multiple threads
|
||||
before creating a virtual machine have to call KVM_S390_ENABLE_SIE, or will
|
||||
observe an error calling KVM_CREATE_VM. Switching on PGSTE is a one-time
|
||||
operation, is not reversible, and will persist over the entire lifetime of
|
||||
the calling process. It does not have any user-visible effect other than a small
|
||||
performance penalty.
|
||||
|
||||
2. ioctl calls to the kvm-vm file descriptor
|
||||
KVM does support the following ioctls on s390 that are common with other
|
||||
architectures and do behave the same:
|
||||
KVM_CREATE_VCPU
|
||||
KVM_SET_USER_MEMORY_REGION (*) see note
|
||||
KVM_GET_DIRTY_LOG (**) see note
|
||||
|
||||
Notes:
|
||||
* kvm does only allow exactly one memory slot on s390, which has to start
|
||||
at guest absolute address zero and at a user address that is aligned on any
|
||||
page boundary. This hardware "limitation" allows us to have a few unique
|
||||
optimizations. The memory slot doesn't have to be filled
|
||||
with memory actually, it may contain sparse holes. That said, with different
|
||||
user memory layout this does still allow a large flexibility when
|
||||
doing the guest memory setup.
|
||||
** KVM_GET_DIRTY_LOG doesn't work properly yet. The user will receive an empty
|
||||
log. This ioctl call is only needed for guest migration, and we intend to
|
||||
implement this one in the future.
|
||||
|
||||
In addition, on s390 the following architecture specific ioctls for the kvm-vm
|
||||
file descriptor are supported:
|
||||
ioctl: KVM_S390_INTERRUPT
|
||||
args: struct kvm_s390_interrupt *
|
||||
see also: include/linux/kvm.h
|
||||
This ioctl is used to submit a floating interrupt for a virtual machine.
|
||||
Floating interrupts may be delivered to any virtual cpu in the configuration.
|
||||
Only some interrupt types defined in include/linux/kvm.h make sense when
|
||||
submitted as floating interrupts. The following interrupts are not considered
|
||||
to be useful as floating interrupts, and a call to inject them will result in
|
||||
-EINVAL error code: program interrupts and interprocessor signals. Valid
|
||||
floating interrupts are:
|
||||
KVM_S390_INT_VIRTIO
|
||||
KVM_S390_INT_SERVICE
|
||||
|
||||
3. ioctl calls to the kvm-vcpu file descriptor
|
||||
KVM does support the following ioctls on s390 that are common with other
|
||||
architectures and do behave the same:
|
||||
KVM_RUN
|
||||
KVM_GET_REGS
|
||||
KVM_SET_REGS
|
||||
KVM_GET_SREGS
|
||||
KVM_SET_SREGS
|
||||
KVM_GET_FPU
|
||||
KVM_SET_FPU
|
||||
|
||||
In addition, on s390 the following architecture specific ioctls for the
|
||||
kvm-vcpu file descriptor are supported:
|
||||
ioctl: KVM_S390_INTERRUPT
|
||||
args: struct kvm_s390_interrupt *
|
||||
see also: include/linux/kvm.h
|
||||
This ioctl is used to submit an interrupt for a specific virtual cpu.
|
||||
Only some interrupt types defined in include/linux/kvm.h make sense when
|
||||
submitted for a specific cpu. The following interrupts are not considered
|
||||
to be useful, and a call to inject them will result in -EINVAL error code:
|
||||
service processor calls and virtio interrupts. Valid interrupt types are:
|
||||
KVM_S390_PROGRAM_INT
|
||||
KVM_S390_SIGP_STOP
|
||||
KVM_S390_RESTART
|
||||
KVM_S390_SIGP_SET_PREFIX
|
||||
KVM_S390_INT_EMERGENCY
|
||||
|
||||
ioctl: KVM_S390_STORE_STATUS
|
||||
args: unsigned long
|
||||
see also: include/linux/kvm.h
|
||||
This ioctl stores the state of the cpu at the guest real address given as
|
||||
argument, unless one of the following values defined in include/linux/kvm.h
|
||||
is given as argument:
|
||||
KVM_S390_STORE_STATUS_NOADDR - the CPU stores its status to the save area in
|
||||
absolute lowcore as defined by the principles of operation
|
||||
KVM_S390_STORE_STATUS_PREFIXED - the CPU stores its status to the save area in
|
||||
its prefix page just like the dump tool that comes with zipl. This is useful
|
||||
to create a system dump for use with lkcdutils or crash.
|
||||
|
||||
ioctl: KVM_S390_SET_INITIAL_PSW
|
||||
args: struct kvm_s390_psw *
|
||||
see also: include/linux/kvm.h
|
||||
This ioctl can be used to set the processor status word (psw) of a stopped cpu
|
||||
prior to running it with KVM_RUN. Note that this call is not required to modify
|
||||
the psw during sie intercepts that fall back to userspace because struct kvm_run
|
||||
does contain the psw, and this value is evaluated during reentry of KVM_RUN
|
||||
after the intercept exit was recognized.
|
||||
|
||||
ioctl: KVM_S390_INITIAL_RESET
|
||||
args: none
|
||||
see also: include/linux/kvm.h
|
||||
This ioctl can be used to perform an initial cpu reset as defined by the
|
||||
principles of operation. The target cpu has to be in stopped state.
|
||||
@ -258,6 +258,9 @@ struct kvm_vcpu_stat {
|
||||
u32 diagnose_10;
|
||||
u32 diagnose_44;
|
||||
u32 diagnose_9c;
|
||||
u32 diagnose_258;
|
||||
u32 diagnose_308;
|
||||
u32 diagnose_500;
|
||||
};
|
||||
|
||||
#define PGM_OPERATION 0x01
|
||||
@ -630,7 +633,6 @@ extern char sie_exit;
|
||||
|
||||
static inline void kvm_arch_hardware_disable(void) {}
|
||||
static inline void kvm_arch_check_processor_compat(void *rtn) {}
|
||||
static inline void kvm_arch_exit(void) {}
|
||||
static inline void kvm_arch_sync_events(struct kvm *kvm) {}
|
||||
static inline void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {}
|
||||
static inline void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu) {}
|
||||
|
||||
@ -27,13 +27,13 @@ static int diag_release_pages(struct kvm_vcpu *vcpu)
|
||||
|
||||
start = vcpu->run->s.regs.gprs[(vcpu->arch.sie_block->ipa & 0xf0) >> 4];
|
||||
end = vcpu->run->s.regs.gprs[vcpu->arch.sie_block->ipa & 0xf] + 4096;
|
||||
vcpu->stat.diagnose_10++;
|
||||
|
||||
if (start & ~PAGE_MASK || end & ~PAGE_MASK || start >= end
|
||||
|| start < 2 * PAGE_SIZE)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "diag release pages %lX %lX", start, end);
|
||||
vcpu->stat.diagnose_10++;
|
||||
|
||||
/*
|
||||
* We checked for start >= end above, so lets check for the
|
||||
@ -75,6 +75,9 @@ static int __diag_page_ref_service(struct kvm_vcpu *vcpu)
|
||||
u16 rx = (vcpu->arch.sie_block->ipa & 0xf0) >> 4;
|
||||
u16 ry = (vcpu->arch.sie_block->ipa & 0x0f);
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "diag page reference parameter block at 0x%llx",
|
||||
vcpu->run->s.regs.gprs[rx]);
|
||||
vcpu->stat.diagnose_258++;
|
||||
if (vcpu->run->s.regs.gprs[rx] & 7)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
rc = read_guest(vcpu, vcpu->run->s.regs.gprs[rx], rx, &parm, sizeof(parm));
|
||||
@ -85,6 +88,9 @@ static int __diag_page_ref_service(struct kvm_vcpu *vcpu)
|
||||
|
||||
switch (parm.subcode) {
|
||||
case 0: /* TOKEN */
|
||||
VCPU_EVENT(vcpu, 3, "pageref token addr 0x%llx "
|
||||
"select mask 0x%llx compare mask 0x%llx",
|
||||
parm.token_addr, parm.select_mask, parm.compare_mask);
|
||||
if (vcpu->arch.pfault_token != KVM_S390_PFAULT_TOKEN_INVALID) {
|
||||
/*
|
||||
* If the pagefault handshake is already activated,
|
||||
@ -114,6 +120,7 @@ static int __diag_page_ref_service(struct kvm_vcpu *vcpu)
|
||||
* the cancel, therefore to reduce code complexity, we assume
|
||||
* all outstanding tokens are already pending.
|
||||
*/
|
||||
VCPU_EVENT(vcpu, 3, "pageref cancel addr 0x%llx", parm.token_addr);
|
||||
if (parm.token_addr || parm.select_mask ||
|
||||
parm.compare_mask || parm.zarch)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
@ -174,7 +181,8 @@ static int __diag_ipl_functions(struct kvm_vcpu *vcpu)
|
||||
unsigned int reg = vcpu->arch.sie_block->ipa & 0xf;
|
||||
unsigned long subcode = vcpu->run->s.regs.gprs[reg] & 0xffff;
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "diag ipl functions, subcode %lx", subcode);
|
||||
VCPU_EVENT(vcpu, 3, "diag ipl functions, subcode %lx", subcode);
|
||||
vcpu->stat.diagnose_308++;
|
||||
switch (subcode) {
|
||||
case 3:
|
||||
vcpu->run->s390_reset_flags = KVM_S390_RESET_CLEAR;
|
||||
@ -202,6 +210,7 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
int ret;
|
||||
|
||||
vcpu->stat.diagnose_500++;
|
||||
/* No virtio-ccw notification? Get out quickly. */
|
||||
if (!vcpu->kvm->arch.css_support ||
|
||||
(vcpu->run->s.regs.gprs[1] != KVM_S390_VIRTIO_CCW_NOTIFY))
|
||||
|
||||
@ -473,10 +473,45 @@ static void filter_guest_per_event(struct kvm_vcpu *vcpu)
|
||||
vcpu->arch.sie_block->iprcc &= ~PGM_PER;
|
||||
}
|
||||
|
||||
#define pssec(vcpu) (vcpu->arch.sie_block->gcr[1] & _ASCE_SPACE_SWITCH)
|
||||
#define hssec(vcpu) (vcpu->arch.sie_block->gcr[13] & _ASCE_SPACE_SWITCH)
|
||||
#define old_ssec(vcpu) ((vcpu->arch.sie_block->tecmc >> 31) & 0x1)
|
||||
#define old_as_is_home(vcpu) !(vcpu->arch.sie_block->tecmc & 0xffff)
|
||||
|
||||
void kvm_s390_handle_per_event(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
int new_as;
|
||||
|
||||
if (debug_exit_required(vcpu))
|
||||
vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
|
||||
|
||||
filter_guest_per_event(vcpu);
|
||||
|
||||
/*
|
||||
* Only RP, SAC, SACF, PT, PTI, PR, PC instructions can trigger
|
||||
* a space-switch event. PER events enforce space-switch events
|
||||
* for these instructions. So if no PER event for the guest is left,
|
||||
* we might have to filter the space-switch element out, too.
|
||||
*/
|
||||
if (vcpu->arch.sie_block->iprcc == PGM_SPACE_SWITCH) {
|
||||
vcpu->arch.sie_block->iprcc = 0;
|
||||
new_as = psw_bits(vcpu->arch.sie_block->gpsw).as;
|
||||
|
||||
/*
|
||||
* If the AS changed from / to home, we had RP, SAC or SACF
|
||||
* instruction. Check primary and home space-switch-event
|
||||
* controls. (theoretically home -> home produced no event)
|
||||
*/
|
||||
if (((new_as == PSW_AS_HOME) ^ old_as_is_home(vcpu)) &&
|
||||
(pssec(vcpu) || hssec(vcpu)))
|
||||
vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
|
||||
|
||||
/*
|
||||
* PT, PTI, PR, PC instruction operate on primary AS only. Check
|
||||
* if the primary-space-switch-event control was or got set.
|
||||
*/
|
||||
if (new_as == PSW_AS_PRIMARY && !old_as_is_home(vcpu) &&
|
||||
(pssec(vcpu) || old_ssec(vcpu)))
|
||||
vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
|
||||
}
|
||||
}
|
||||
|
||||
@ -30,7 +30,6 @@
|
||||
#define IOINT_SCHID_MASK 0x0000ffff
|
||||
#define IOINT_SSID_MASK 0x00030000
|
||||
#define IOINT_CSSID_MASK 0x03fc0000
|
||||
#define IOINT_AI_MASK 0x04000000
|
||||
#define PFAULT_INIT 0x0600
|
||||
#define PFAULT_DONE 0x0680
|
||||
#define VIRTIO_PARAM 0x0d00
|
||||
@ -311,8 +310,8 @@ static int __must_check __deliver_pfault_init(struct kvm_vcpu *vcpu)
|
||||
li->irq.ext.ext_params2 = 0;
|
||||
spin_unlock(&li->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: pfault init parm:%x,parm64:%llx",
|
||||
0, ext.ext_params2);
|
||||
VCPU_EVENT(vcpu, 4, "deliver: pfault init token 0x%llx",
|
||||
ext.ext_params2);
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_INT_PFAULT_INIT,
|
||||
0, ext.ext_params2);
|
||||
@ -368,7 +367,7 @@ static int __must_check __deliver_machine_check(struct kvm_vcpu *vcpu)
|
||||
spin_unlock(&fi->lock);
|
||||
|
||||
if (deliver) {
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: machine check mcic=%llx",
|
||||
VCPU_EVENT(vcpu, 3, "deliver: machine check mcic 0x%llx",
|
||||
mchk.mcic);
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_MCHK,
|
||||
@ -403,7 +402,7 @@ static int __must_check __deliver_restart(struct kvm_vcpu *vcpu)
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
int rc;
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu restart");
|
||||
VCPU_EVENT(vcpu, 3, "%s", "deliver: cpu restart");
|
||||
vcpu->stat.deliver_restart_signal++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id, KVM_S390_RESTART, 0, 0);
|
||||
|
||||
@ -427,7 +426,6 @@ static int __must_check __deliver_set_prefix(struct kvm_vcpu *vcpu)
|
||||
clear_bit(IRQ_PEND_SET_PREFIX, &li->pending_irqs);
|
||||
spin_unlock(&li->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: set prefix to %x", prefix.address);
|
||||
vcpu->stat.deliver_prefix_signal++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_SIGP_SET_PREFIX,
|
||||
@ -450,7 +448,7 @@ static int __must_check __deliver_emergency_signal(struct kvm_vcpu *vcpu)
|
||||
clear_bit(IRQ_PEND_EXT_EMERGENCY, &li->pending_irqs);
|
||||
spin_unlock(&li->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp emerg");
|
||||
VCPU_EVENT(vcpu, 4, "%s", "deliver: sigp emerg");
|
||||
vcpu->stat.deliver_emergency_signal++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id, KVM_S390_INT_EMERGENCY,
|
||||
cpu_addr, 0);
|
||||
@ -477,7 +475,7 @@ static int __must_check __deliver_external_call(struct kvm_vcpu *vcpu)
|
||||
clear_bit(IRQ_PEND_EXT_EXTERNAL, &li->pending_irqs);
|
||||
spin_unlock(&li->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp ext call");
|
||||
VCPU_EVENT(vcpu, 4, "%s", "deliver: sigp ext call");
|
||||
vcpu->stat.deliver_external_call++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_INT_EXTERNAL_CALL,
|
||||
@ -506,7 +504,7 @@ static int __must_check __deliver_prog(struct kvm_vcpu *vcpu)
|
||||
memset(&li->irq.pgm, 0, sizeof(pgm_info));
|
||||
spin_unlock(&li->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: pgm check code:%x, ilc:%x",
|
||||
VCPU_EVENT(vcpu, 3, "deliver: program irq code 0x%x, ilc:%d",
|
||||
pgm_info.code, ilc);
|
||||
vcpu->stat.deliver_program_int++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id, KVM_S390_PROGRAM_INT,
|
||||
@ -622,7 +620,7 @@ static int __must_check __deliver_service(struct kvm_vcpu *vcpu)
|
||||
clear_bit(IRQ_PEND_EXT_SERVICE, &fi->pending_irqs);
|
||||
spin_unlock(&fi->lock);
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: sclp parm:%x",
|
||||
VCPU_EVENT(vcpu, 4, "deliver: sclp parameter 0x%x",
|
||||
ext.ext_params);
|
||||
vcpu->stat.deliver_service_signal++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id, KVM_S390_INT_SERVICE,
|
||||
@ -651,9 +649,6 @@ static int __must_check __deliver_pfault_done(struct kvm_vcpu *vcpu)
|
||||
struct kvm_s390_interrupt_info,
|
||||
list);
|
||||
if (inti) {
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_INT_PFAULT_DONE, 0,
|
||||
inti->ext.ext_params2);
|
||||
list_del(&inti->list);
|
||||
fi->counters[FIRQ_CNTR_PFAULT] -= 1;
|
||||
}
|
||||
@ -662,6 +657,12 @@ static int __must_check __deliver_pfault_done(struct kvm_vcpu *vcpu)
|
||||
spin_unlock(&fi->lock);
|
||||
|
||||
if (inti) {
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
KVM_S390_INT_PFAULT_DONE, 0,
|
||||
inti->ext.ext_params2);
|
||||
VCPU_EVENT(vcpu, 4, "deliver: pfault done token 0x%llx",
|
||||
inti->ext.ext_params2);
|
||||
|
||||
rc = put_guest_lc(vcpu, EXT_IRQ_CP_SERVICE,
|
||||
(u16 *)__LC_EXT_INT_CODE);
|
||||
rc |= put_guest_lc(vcpu, PFAULT_DONE,
|
||||
@ -691,7 +692,7 @@ static int __must_check __deliver_virtio(struct kvm_vcpu *vcpu)
|
||||
list);
|
||||
if (inti) {
|
||||
VCPU_EVENT(vcpu, 4,
|
||||
"interrupt: virtio parm:%x,parm64:%llx",
|
||||
"deliver: virtio parm: 0x%x,parm64: 0x%llx",
|
||||
inti->ext.ext_params, inti->ext.ext_params2);
|
||||
vcpu->stat.deliver_virtio_interrupt++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
@ -741,7 +742,7 @@ static int __must_check __deliver_io(struct kvm_vcpu *vcpu,
|
||||
struct kvm_s390_interrupt_info,
|
||||
list);
|
||||
if (inti) {
|
||||
VCPU_EVENT(vcpu, 4, "interrupt: I/O %llx", inti->type);
|
||||
VCPU_EVENT(vcpu, 4, "deliver: I/O 0x%llx", inti->type);
|
||||
vcpu->stat.deliver_io_int++;
|
||||
trace_kvm_s390_deliver_interrupt(vcpu->vcpu_id,
|
||||
inti->type,
|
||||
@ -864,7 +865,7 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
|
||||
|
||||
__set_cpu_idle(vcpu);
|
||||
hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL);
|
||||
VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime);
|
||||
VCPU_EVENT(vcpu, 4, "enabled wait via clock comparator: %llu ns", sltime);
|
||||
no_timer:
|
||||
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
|
||||
kvm_vcpu_block(vcpu);
|
||||
@ -968,6 +969,10 @@ static int __inject_prog(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: program irq code 0x%x", irq->u.pgm.code);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_PROGRAM_INT,
|
||||
irq->u.pgm.code, 0);
|
||||
|
||||
li->irq.pgm = irq->u.pgm;
|
||||
set_bit(IRQ_PEND_PROG, &li->pending_irqs);
|
||||
return 0;
|
||||
@ -978,9 +983,6 @@ int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code)
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
struct kvm_s390_irq irq;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: program check %d (from kernel)", code);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_PROGRAM_INT, code,
|
||||
0, 1);
|
||||
spin_lock(&li->lock);
|
||||
irq.u.pgm.code = code;
|
||||
__inject_prog(vcpu, &irq);
|
||||
@ -996,10 +998,6 @@ int kvm_s390_inject_prog_irq(struct kvm_vcpu *vcpu,
|
||||
struct kvm_s390_irq irq;
|
||||
int rc;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: prog irq %d (from kernel)",
|
||||
pgm_info->code);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_PROGRAM_INT,
|
||||
pgm_info->code, 0, 1);
|
||||
spin_lock(&li->lock);
|
||||
irq.u.pgm = *pgm_info;
|
||||
rc = __inject_prog(vcpu, &irq);
|
||||
@ -1012,11 +1010,11 @@ static int __inject_pfault_init(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: external irq params:%x, params2:%llx",
|
||||
irq->u.ext.ext_params, irq->u.ext.ext_params2);
|
||||
VCPU_EVENT(vcpu, 4, "inject: pfault init parameter block at 0x%llx",
|
||||
irq->u.ext.ext_params2);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_INT_PFAULT_INIT,
|
||||
irq->u.ext.ext_params,
|
||||
irq->u.ext.ext_params2, 2);
|
||||
irq->u.ext.ext_params2);
|
||||
|
||||
li->irq.ext = irq->u.ext;
|
||||
set_bit(IRQ_PEND_PFAULT_INIT, &li->pending_irqs);
|
||||
@ -1045,10 +1043,10 @@ static int __inject_extcall(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
struct kvm_s390_extcall_info *extcall = &li->irq.extcall;
|
||||
uint16_t src_id = irq->u.extcall.code;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: external call source-cpu:%u",
|
||||
VCPU_EVENT(vcpu, 4, "inject: external call source-cpu:%u",
|
||||
src_id);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_INT_EXTERNAL_CALL,
|
||||
src_id, 0, 2);
|
||||
src_id, 0);
|
||||
|
||||
/* sending vcpu invalid */
|
||||
if (src_id >= KVM_MAX_VCPUS ||
|
||||
@ -1070,10 +1068,10 @@ static int __inject_set_prefix(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
struct kvm_s390_prefix_info *prefix = &li->irq.prefix;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: set prefix to %x (from user)",
|
||||
VCPU_EVENT(vcpu, 3, "inject: set prefix to %x",
|
||||
irq->u.prefix.address);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_SIGP_SET_PREFIX,
|
||||
irq->u.prefix.address, 0, 2);
|
||||
irq->u.prefix.address, 0);
|
||||
|
||||
if (!is_vcpu_stopped(vcpu))
|
||||
return -EBUSY;
|
||||
@ -1090,7 +1088,7 @@ static int __inject_sigp_stop(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
struct kvm_s390_stop_info *stop = &li->irq.stop;
|
||||
int rc = 0;
|
||||
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_SIGP_STOP, 0, 0, 2);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_SIGP_STOP, 0, 0);
|
||||
|
||||
if (irq->u.stop.flags & ~KVM_S390_STOP_SUPP_FLAGS)
|
||||
return -EINVAL;
|
||||
@ -1114,8 +1112,8 @@ static int __inject_sigp_restart(struct kvm_vcpu *vcpu,
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: restart type %llx", irq->type);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_RESTART, 0, 0, 2);
|
||||
VCPU_EVENT(vcpu, 3, "%s", "inject: restart int");
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_RESTART, 0, 0);
|
||||
|
||||
set_bit(IRQ_PEND_RESTART, &li->pending_irqs);
|
||||
return 0;
|
||||
@ -1126,10 +1124,10 @@ static int __inject_sigp_emergency(struct kvm_vcpu *vcpu,
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: emergency %u\n",
|
||||
VCPU_EVENT(vcpu, 4, "inject: emergency from cpu %u",
|
||||
irq->u.emerg.code);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_INT_EMERGENCY,
|
||||
irq->u.emerg.code, 0, 2);
|
||||
irq->u.emerg.code, 0);
|
||||
|
||||
set_bit(irq->u.emerg.code, li->sigp_emerg_pending);
|
||||
set_bit(IRQ_PEND_EXT_EMERGENCY, &li->pending_irqs);
|
||||
@ -1142,10 +1140,10 @@ static int __inject_mchk(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
struct kvm_s390_mchk_info *mchk = &li->irq.mchk;
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "inject: machine check parm64:%llx",
|
||||
VCPU_EVENT(vcpu, 3, "inject: machine check mcic 0x%llx",
|
||||
irq->u.mchk.mcic);
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_MCHK, 0,
|
||||
irq->u.mchk.mcic, 2);
|
||||
irq->u.mchk.mcic);
|
||||
|
||||
/*
|
||||
* Because repressible machine checks can be indicated along with
|
||||
@ -1172,9 +1170,9 @@ static int __inject_ckc(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: type %x", KVM_S390_INT_CLOCK_COMP);
|
||||
VCPU_EVENT(vcpu, 3, "%s", "inject: clock comparator external");
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_INT_CLOCK_COMP,
|
||||
0, 0, 2);
|
||||
0, 0);
|
||||
|
||||
set_bit(IRQ_PEND_EXT_CLOCK_COMP, &li->pending_irqs);
|
||||
atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
|
||||
@ -1185,9 +1183,9 @@ static int __inject_cpu_timer(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "inject: type %x", KVM_S390_INT_CPU_TIMER);
|
||||
VCPU_EVENT(vcpu, 3, "%s", "inject: cpu timer external");
|
||||
trace_kvm_s390_inject_vcpu(vcpu->vcpu_id, KVM_S390_INT_CPU_TIMER,
|
||||
0, 0, 2);
|
||||
0, 0);
|
||||
|
||||
set_bit(IRQ_PEND_EXT_CPU_TIMER, &li->pending_irqs);
|
||||
atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
|
||||
@ -1435,20 +1433,20 @@ int kvm_s390_inject_vm(struct kvm *kvm,
|
||||
inti->ext.ext_params2 = s390int->parm64;
|
||||
break;
|
||||
case KVM_S390_INT_SERVICE:
|
||||
VM_EVENT(kvm, 5, "inject: sclp parm:%x", s390int->parm);
|
||||
VM_EVENT(kvm, 4, "inject: sclp parm:%x", s390int->parm);
|
||||
inti->ext.ext_params = s390int->parm;
|
||||
break;
|
||||
case KVM_S390_INT_PFAULT_DONE:
|
||||
inti->ext.ext_params2 = s390int->parm64;
|
||||
break;
|
||||
case KVM_S390_MCHK:
|
||||
VM_EVENT(kvm, 5, "inject: machine check parm64:%llx",
|
||||
VM_EVENT(kvm, 3, "inject: machine check mcic 0x%llx",
|
||||
s390int->parm64);
|
||||
inti->mchk.cr14 = s390int->parm; /* upper bits are not used */
|
||||
inti->mchk.mcic = s390int->parm64;
|
||||
break;
|
||||
case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:
|
||||
if (inti->type & IOINT_AI_MASK)
|
||||
if (inti->type & KVM_S390_INT_IO_AI_MASK)
|
||||
VM_EVENT(kvm, 5, "%s", "inject: I/O (AI)");
|
||||
else
|
||||
VM_EVENT(kvm, 5, "inject: I/O css %x ss %x schid %04x",
|
||||
@ -1535,8 +1533,6 @@ static int do_inject_vcpu(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
|
||||
|
||||
switch (irq->type) {
|
||||
case KVM_S390_PROGRAM_INT:
|
||||
VCPU_EVENT(vcpu, 3, "inject: program check %d (from user)",
|
||||
irq->u.pgm.code);
|
||||
rc = __inject_prog(vcpu, irq);
|
||||
break;
|
||||
case KVM_S390_SIGP_SET_PREFIX:
|
||||
|
||||
@ -108,6 +108,9 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
|
||||
{ "diagnose_10", VCPU_STAT(diagnose_10) },
|
||||
{ "diagnose_44", VCPU_STAT(diagnose_44) },
|
||||
{ "diagnose_9c", VCPU_STAT(diagnose_9c) },
|
||||
{ "diagnose_258", VCPU_STAT(diagnose_258) },
|
||||
{ "diagnose_308", VCPU_STAT(diagnose_308) },
|
||||
{ "diagnose_500", VCPU_STAT(diagnose_500) },
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
@ -124,6 +127,7 @@ unsigned long kvm_s390_fac_list_mask_size(void)
|
||||
}
|
||||
|
||||
static struct gmap_notifier gmap_notifier;
|
||||
debug_info_t *kvm_s390_dbf;
|
||||
|
||||
/* Section: not file related */
|
||||
int kvm_arch_hardware_enable(void)
|
||||
@ -148,10 +152,24 @@ void kvm_arch_hardware_unsetup(void)
|
||||
|
||||
int kvm_arch_init(void *opaque)
|
||||
{
|
||||
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)) {
|
||||
debug_unregister(kvm_s390_dbf);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Register floating interrupt controller interface. */
|
||||
return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC);
|
||||
}
|
||||
|
||||
void kvm_arch_exit(void)
|
||||
{
|
||||
debug_unregister(kvm_s390_dbf);
|
||||
}
|
||||
|
||||
/* Section: device related */
|
||||
long kvm_arch_dev_ioctl(struct file *filp,
|
||||
unsigned int ioctl, unsigned long arg)
|
||||
@ -281,10 +299,12 @@ static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
|
||||
|
||||
switch (cap->cap) {
|
||||
case KVM_CAP_S390_IRQCHIP:
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP");
|
||||
kvm->arch.use_irqchip = 1;
|
||||
r = 0;
|
||||
break;
|
||||
case KVM_CAP_S390_USER_SIGP:
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP");
|
||||
kvm->arch.user_sigp = 1;
|
||||
r = 0;
|
||||
break;
|
||||
@ -295,8 +315,11 @@ static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
|
||||
r = 0;
|
||||
} else
|
||||
r = -EINVAL;
|
||||
VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s",
|
||||
r ? "(not available)" : "(success)");
|
||||
break;
|
||||
case KVM_CAP_S390_USER_STSI:
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI");
|
||||
kvm->arch.user_stsi = 1;
|
||||
r = 0;
|
||||
break;
|
||||
@ -314,6 +337,8 @@ static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *att
|
||||
switch (attr->attr) {
|
||||
case KVM_S390_VM_MEM_LIMIT_SIZE:
|
||||
ret = 0;
|
||||
VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes",
|
||||
kvm->arch.gmap->asce_end);
|
||||
if (put_user(kvm->arch.gmap->asce_end, (u64 __user *)attr->addr))
|
||||
ret = -EFAULT;
|
||||
break;
|
||||
@ -330,7 +355,13 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *att
|
||||
unsigned int idx;
|
||||
switch (attr->attr) {
|
||||
case KVM_S390_VM_MEM_ENABLE_CMMA:
|
||||
/* enable CMMA only for z10 and later (EDAT_1) */
|
||||
ret = -EINVAL;
|
||||
if (!MACHINE_IS_LPAR || !MACHINE_HAS_EDAT1)
|
||||
break;
|
||||
|
||||
ret = -EBUSY;
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support");
|
||||
mutex_lock(&kvm->lock);
|
||||
if (atomic_read(&kvm->online_vcpus) == 0) {
|
||||
kvm->arch.use_cmma = 1;
|
||||
@ -339,6 +370,11 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *att
|
||||
mutex_unlock(&kvm->lock);
|
||||
break;
|
||||
case KVM_S390_VM_MEM_CLR_CMMA:
|
||||
ret = -EINVAL;
|
||||
if (!kvm->arch.use_cmma)
|
||||
break;
|
||||
|
||||
VM_EVENT(kvm, 3, "%s", "RESET: CMMA states");
|
||||
mutex_lock(&kvm->lock);
|
||||
idx = srcu_read_lock(&kvm->srcu);
|
||||
s390_reset_cmma(kvm->arch.gmap->mm);
|
||||
@ -374,6 +410,7 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *att
|
||||
}
|
||||
}
|
||||
mutex_unlock(&kvm->lock);
|
||||
VM_EVENT(kvm, 3, "SET: max guest memory: %lu bytes", new_limit);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
@ -400,22 +437,26 @@ static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr)
|
||||
kvm->arch.crypto.crycb->aes_wrapping_key_mask,
|
||||
sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
|
||||
kvm->arch.crypto.aes_kw = 1;
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support");
|
||||
break;
|
||||
case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
|
||||
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;
|
||||
VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support");
|
||||
break;
|
||||
case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
|
||||
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));
|
||||
VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support");
|
||||
break;
|
||||
case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
|
||||
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));
|
||||
VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support");
|
||||
break;
|
||||
default:
|
||||
mutex_unlock(&kvm->lock);
|
||||
@ -440,6 +481,7 @@ static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
|
||||
|
||||
if (gtod_high != 0)
|
||||
return -EINVAL;
|
||||
VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x\n", gtod_high);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -465,6 +507,7 @@ static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
|
||||
cur_vcpu->arch.sie_block->epoch = kvm->arch.epoch;
|
||||
kvm_s390_vcpu_unblock_all(kvm);
|
||||
mutex_unlock(&kvm->lock);
|
||||
VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx\n", gtod);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -496,6 +539,7 @@ static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
|
||||
if (copy_to_user((void __user *)attr->addr, >od_high,
|
||||
sizeof(gtod_high)))
|
||||
return -EFAULT;
|
||||
VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x\n", gtod_high);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -512,6 +556,7 @@ static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
|
||||
gtod = host_tod + kvm->arch.epoch;
|
||||
if (copy_to_user((void __user *)attr->addr, >od, sizeof(gtod)))
|
||||
return -EFAULT;
|
||||
VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx\n", gtod);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -821,7 +866,9 @@ static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args)
|
||||
}
|
||||
|
||||
/* Enable storage key handling for the guest */
|
||||
s390_enable_skey();
|
||||
r = s390_enable_skey();
|
||||
if (r)
|
||||
goto out;
|
||||
|
||||
for (i = 0; i < args->count; i++) {
|
||||
hva = gfn_to_hva(kvm, args->start_gfn + i);
|
||||
@ -1043,7 +1090,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
|
||||
|
||||
sprintf(debug_name, "kvm-%u", current->pid);
|
||||
|
||||
kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
|
||||
kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long));
|
||||
if (!kvm->arch.dbf)
|
||||
goto out_err;
|
||||
|
||||
@ -1086,7 +1133,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
|
||||
mutex_init(&kvm->arch.ipte_mutex);
|
||||
|
||||
debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
|
||||
VM_EVENT(kvm, 3, "%s", "vm created");
|
||||
VM_EVENT(kvm, 3, "vm created with type %lu", type);
|
||||
|
||||
if (type & KVM_VM_S390_UCONTROL) {
|
||||
kvm->arch.gmap = NULL;
|
||||
@ -1103,6 +1150,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
|
||||
kvm->arch.epoch = 0;
|
||||
|
||||
spin_lock_init(&kvm->arch.start_stop_lock);
|
||||
KVM_EVENT(3, "vm 0x%p created by pid %u", kvm, current->pid);
|
||||
|
||||
return 0;
|
||||
out_err:
|
||||
@ -1110,6 +1158,7 @@ out_err:
|
||||
free_page((unsigned long)kvm->arch.model.fac);
|
||||
debug_unregister(kvm->arch.dbf);
|
||||
free_page((unsigned long)(kvm->arch.sca));
|
||||
KVM_EVENT(3, "creation of vm failed: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
@ -1131,7 +1180,7 @@ void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
|
||||
if (kvm_is_ucontrol(vcpu->kvm))
|
||||
gmap_free(vcpu->arch.gmap);
|
||||
|
||||
if (kvm_s390_cmma_enabled(vcpu->kvm))
|
||||
if (vcpu->kvm->arch.use_cmma)
|
||||
kvm_s390_vcpu_unsetup_cmma(vcpu);
|
||||
free_page((unsigned long)(vcpu->arch.sie_block));
|
||||
|
||||
@ -1166,6 +1215,7 @@ void kvm_arch_destroy_vm(struct kvm *kvm)
|
||||
gmap_free(kvm->arch.gmap);
|
||||
kvm_s390_destroy_adapters(kvm);
|
||||
kvm_s390_clear_float_irqs(kvm);
|
||||
KVM_EVENT(3, "vm 0x%p destroyed", kvm);
|
||||
}
|
||||
|
||||
/* Section: vcpu related */
|
||||
@ -1342,7 +1392,7 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
|
||||
}
|
||||
vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
|
||||
|
||||
if (kvm_s390_cmma_enabled(vcpu->kvm)) {
|
||||
if (vcpu->kvm->arch.use_cmma) {
|
||||
rc = kvm_s390_vcpu_setup_cmma(vcpu);
|
||||
if (rc)
|
||||
return rc;
|
||||
@ -1723,18 +1773,6 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
|
||||
return rc;
|
||||
}
|
||||
|
||||
bool kvm_s390_cmma_enabled(struct kvm *kvm)
|
||||
{
|
||||
if (!MACHINE_IS_LPAR)
|
||||
return false;
|
||||
/* only enable for z10 and later */
|
||||
if (!MACHINE_HAS_EDAT1)
|
||||
return false;
|
||||
if (!kvm->arch.use_cmma)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool ibs_enabled(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
|
||||
@ -2340,6 +2378,7 @@ static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
|
||||
case KVM_CAP_S390_CSS_SUPPORT:
|
||||
if (!vcpu->kvm->arch.css_support) {
|
||||
vcpu->kvm->arch.css_support = 1;
|
||||
VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support");
|
||||
trace_kvm_s390_enable_css(vcpu->kvm);
|
||||
}
|
||||
r = 0;
|
||||
|
||||
@ -27,6 +27,13 @@ typedef int (*intercept_handler_t)(struct kvm_vcpu *vcpu);
|
||||
#define TDB_FORMAT1 1
|
||||
#define IS_ITDB_VALID(vcpu) ((*(char *)vcpu->arch.sie_block->itdba == TDB_FORMAT1))
|
||||
|
||||
extern debug_info_t *kvm_s390_dbf;
|
||||
#define KVM_EVENT(d_loglevel, d_string, d_args...)\
|
||||
do { \
|
||||
debug_sprintf_event(kvm_s390_dbf, d_loglevel, d_string "\n", \
|
||||
d_args); \
|
||||
} while (0)
|
||||
|
||||
#define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\
|
||||
do { \
|
||||
debug_sprintf_event(d_kvm->arch.dbf, d_loglevel, d_string "\n", \
|
||||
@ -65,6 +72,8 @@ static inline u32 kvm_s390_get_prefix(struct kvm_vcpu *vcpu)
|
||||
|
||||
static inline void kvm_s390_set_prefix(struct kvm_vcpu *vcpu, u32 prefix)
|
||||
{
|
||||
VCPU_EVENT(vcpu, 3, "set prefix of cpu %03u to 0x%x", vcpu->vcpu_id,
|
||||
prefix);
|
||||
vcpu->arch.sie_block->prefix = prefix >> GUEST_PREFIX_SHIFT;
|
||||
kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
|
||||
kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
|
||||
@ -217,8 +226,6 @@ void exit_sie(struct kvm_vcpu *vcpu);
|
||||
void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu);
|
||||
int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu);
|
||||
void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu);
|
||||
/* is cmma enabled */
|
||||
bool kvm_s390_cmma_enabled(struct kvm *kvm);
|
||||
unsigned long kvm_s390_fac_list_mask_size(void);
|
||||
extern unsigned long kvm_s390_fac_list_mask[];
|
||||
|
||||
|
||||
@ -53,6 +53,7 @@ static int handle_set_clock(struct kvm_vcpu *vcpu)
|
||||
kvm_s390_set_psw_cc(vcpu, 3);
|
||||
return 0;
|
||||
}
|
||||
VCPU_EVENT(vcpu, 3, "SCK: setting guest TOD to 0x%llx", val);
|
||||
val = (val - hostclk) & ~0x3fUL;
|
||||
|
||||
mutex_lock(&vcpu->kvm->lock);
|
||||
@ -98,8 +99,6 @@ static int handle_set_prefix(struct kvm_vcpu *vcpu)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
|
||||
|
||||
kvm_s390_set_prefix(vcpu, address);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "setting prefix to %x", address);
|
||||
trace_kvm_s390_handle_prefix(vcpu, 1, address);
|
||||
return 0;
|
||||
}
|
||||
@ -129,7 +128,7 @@ static int handle_store_prefix(struct kvm_vcpu *vcpu)
|
||||
if (rc)
|
||||
return kvm_s390_inject_prog_cond(vcpu, rc);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "storing prefix to %x", address);
|
||||
VCPU_EVENT(vcpu, 3, "STPX: storing prefix 0x%x into 0x%llx", address, operand2);
|
||||
trace_kvm_s390_handle_prefix(vcpu, 0, address);
|
||||
return 0;
|
||||
}
|
||||
@ -155,7 +154,7 @@ static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
|
||||
if (rc)
|
||||
return kvm_s390_inject_prog_cond(vcpu, rc);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "storing cpu address to %llx", ga);
|
||||
VCPU_EVENT(vcpu, 3, "STAP: storing cpu address (%u) to 0x%llx", vcpu_id, ga);
|
||||
trace_kvm_s390_handle_stap(vcpu, ga);
|
||||
return 0;
|
||||
}
|
||||
@ -167,6 +166,7 @@ static int __skey_check_enable(struct kvm_vcpu *vcpu)
|
||||
return rc;
|
||||
|
||||
rc = s390_enable_skey();
|
||||
VCPU_EVENT(vcpu, 3, "%s", "enabling storage keys for guest");
|
||||
trace_kvm_s390_skey_related_inst(vcpu);
|
||||
vcpu->arch.sie_block->ictl &= ~(ICTL_ISKE | ICTL_SSKE | ICTL_RRBE);
|
||||
return rc;
|
||||
@ -370,7 +370,7 @@ static int handle_stfl(struct kvm_vcpu *vcpu)
|
||||
&fac, sizeof(fac));
|
||||
if (rc)
|
||||
return rc;
|
||||
VCPU_EVENT(vcpu, 5, "store facility list value %x", fac);
|
||||
VCPU_EVENT(vcpu, 3, "STFL: store facility list 0x%x", fac);
|
||||
trace_kvm_s390_handle_stfl(vcpu, fac);
|
||||
return 0;
|
||||
}
|
||||
@ -468,7 +468,7 @@ static int handle_stidp(struct kvm_vcpu *vcpu)
|
||||
if (rc)
|
||||
return kvm_s390_inject_prog_cond(vcpu, rc);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "%s", "store cpu id");
|
||||
VCPU_EVENT(vcpu, 3, "STIDP: store cpu id 0x%llx", stidp_data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -521,7 +521,7 @@ static int handle_stsi(struct kvm_vcpu *vcpu)
|
||||
ar_t ar;
|
||||
|
||||
vcpu->stat.instruction_stsi++;
|
||||
VCPU_EVENT(vcpu, 4, "stsi: fc: %x sel1: %x sel2: %x", fc, sel1, sel2);
|
||||
VCPU_EVENT(vcpu, 3, "STSI: fc: %u sel1: %u sel2: %u", fc, sel1, sel2);
|
||||
|
||||
if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
|
||||
@ -758,10 +758,10 @@ static int handle_essa(struct kvm_vcpu *vcpu)
|
||||
struct gmap *gmap;
|
||||
int i;
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "cmma release %d pages", entries);
|
||||
VCPU_EVENT(vcpu, 4, "ESSA: release %d pages", entries);
|
||||
gmap = vcpu->arch.gmap;
|
||||
vcpu->stat.instruction_essa++;
|
||||
if (!kvm_s390_cmma_enabled(vcpu->kvm))
|
||||
if (!vcpu->kvm->arch.use_cmma)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
|
||||
|
||||
if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
|
||||
@ -829,7 +829,7 @@ int kvm_s390_handle_lctl(struct kvm_vcpu *vcpu)
|
||||
if (ga & 3)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "lctl r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
|
||||
VCPU_EVENT(vcpu, 4, "LCTL: r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
|
||||
trace_kvm_s390_handle_lctl(vcpu, 0, reg1, reg3, ga);
|
||||
|
||||
nr_regs = ((reg3 - reg1) & 0xf) + 1;
|
||||
@ -868,7 +868,7 @@ int kvm_s390_handle_stctl(struct kvm_vcpu *vcpu)
|
||||
if (ga & 3)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "stctl r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
|
||||
VCPU_EVENT(vcpu, 4, "STCTL r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
|
||||
trace_kvm_s390_handle_stctl(vcpu, 0, reg1, reg3, ga);
|
||||
|
||||
reg = reg1;
|
||||
@ -902,7 +902,7 @@ static int handle_lctlg(struct kvm_vcpu *vcpu)
|
||||
if (ga & 7)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "lctlg r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
|
||||
VCPU_EVENT(vcpu, 4, "LCTLG: r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
|
||||
trace_kvm_s390_handle_lctl(vcpu, 1, reg1, reg3, ga);
|
||||
|
||||
nr_regs = ((reg3 - reg1) & 0xf) + 1;
|
||||
@ -940,7 +940,7 @@ static int handle_stctg(struct kvm_vcpu *vcpu)
|
||||
if (ga & 7)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
|
||||
|
||||
VCPU_EVENT(vcpu, 5, "stctg r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
|
||||
VCPU_EVENT(vcpu, 4, "STCTG r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
|
||||
trace_kvm_s390_handle_stctl(vcpu, 1, reg1, reg3, ga);
|
||||
|
||||
reg = reg1;
|
||||
|
||||
@ -205,9 +205,6 @@ static int __sigp_set_prefix(struct kvm_vcpu *vcpu, struct kvm_vcpu *dst_vcpu,
|
||||
*reg &= 0xffffffff00000000UL;
|
||||
*reg |= SIGP_STATUS_INCORRECT_STATE;
|
||||
return SIGP_CC_STATUS_STORED;
|
||||
} else if (rc == 0) {
|
||||
VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x",
|
||||
dst_vcpu->vcpu_id, irq.u.prefix.address);
|
||||
}
|
||||
|
||||
return rc;
|
||||
@ -371,7 +368,8 @@ static int handle_sigp_dst(struct kvm_vcpu *vcpu, u8 order_code,
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int handle_sigp_order_in_user_space(struct kvm_vcpu *vcpu, u8 order_code)
|
||||
static int handle_sigp_order_in_user_space(struct kvm_vcpu *vcpu, u8 order_code,
|
||||
u16 cpu_addr)
|
||||
{
|
||||
if (!vcpu->kvm->arch.user_sigp)
|
||||
return 0;
|
||||
@ -414,9 +412,8 @@ static int handle_sigp_order_in_user_space(struct kvm_vcpu *vcpu, u8 order_code)
|
||||
default:
|
||||
vcpu->stat.instruction_sigp_unknown++;
|
||||
}
|
||||
|
||||
VCPU_EVENT(vcpu, 4, "sigp order %u: completely handled in user space",
|
||||
order_code);
|
||||
VCPU_EVENT(vcpu, 3, "SIGP: order %u for CPU %d handled in userspace",
|
||||
order_code, cpu_addr);
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -435,7 +432,7 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
|
||||
return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
|
||||
|
||||
order_code = kvm_s390_get_base_disp_rs(vcpu, NULL);
|
||||
if (handle_sigp_order_in_user_space(vcpu, order_code))
|
||||
if (handle_sigp_order_in_user_space(vcpu, order_code, cpu_addr))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (r1 % 2)
|
||||
|
||||
@ -105,11 +105,22 @@ TRACE_EVENT(kvm_s390_vcpu_start_stop,
|
||||
{KVM_S390_PROGRAM_INT, "program interrupt"}, \
|
||||
{KVM_S390_SIGP_SET_PREFIX, "sigp set prefix"}, \
|
||||
{KVM_S390_RESTART, "sigp restart"}, \
|
||||
{KVM_S390_INT_PFAULT_INIT, "pfault init"}, \
|
||||
{KVM_S390_INT_PFAULT_DONE, "pfault done"}, \
|
||||
{KVM_S390_MCHK, "machine check"}, \
|
||||
{KVM_S390_INT_CLOCK_COMP, "clock comparator"}, \
|
||||
{KVM_S390_INT_CPU_TIMER, "cpu timer"}, \
|
||||
{KVM_S390_INT_VIRTIO, "virtio interrupt"}, \
|
||||
{KVM_S390_INT_SERVICE, "sclp interrupt"}, \
|
||||
{KVM_S390_INT_EMERGENCY, "sigp emergency"}, \
|
||||
{KVM_S390_INT_EXTERNAL_CALL, "sigp ext call"}
|
||||
|
||||
#define get_irq_name(__type) \
|
||||
(__type > KVM_S390_INT_IO_MAX ? \
|
||||
__print_symbolic(__type, kvm_s390_int_type) : \
|
||||
(__type & KVM_S390_INT_IO_AI_MASK ? \
|
||||
"adapter I/O interrupt" : "subchannel I/O interrupt"))
|
||||
|
||||
TRACE_EVENT(kvm_s390_inject_vm,
|
||||
TP_PROTO(__u64 type, __u32 parm, __u64 parm64, int who),
|
||||
TP_ARGS(type, parm, parm64, who),
|
||||
@ -131,22 +142,19 @@ TRACE_EVENT(kvm_s390_inject_vm,
|
||||
TP_printk("inject%s: type:%x (%s) parm:%x parm64:%llx",
|
||||
(__entry->who == 1) ? " (from kernel)" :
|
||||
(__entry->who == 2) ? " (from user)" : "",
|
||||
__entry->inttype,
|
||||
__print_symbolic(__entry->inttype, kvm_s390_int_type),
|
||||
__entry->inttype, get_irq_name(__entry->inttype),
|
||||
__entry->parm, __entry->parm64)
|
||||
);
|
||||
|
||||
TRACE_EVENT(kvm_s390_inject_vcpu,
|
||||
TP_PROTO(unsigned int id, __u64 type, __u32 parm, __u64 parm64, \
|
||||
int who),
|
||||
TP_ARGS(id, type, parm, parm64, who),
|
||||
TP_PROTO(unsigned int id, __u64 type, __u32 parm, __u64 parm64),
|
||||
TP_ARGS(id, type, parm, parm64),
|
||||
|
||||
TP_STRUCT__entry(
|
||||
__field(int, id)
|
||||
__field(__u32, inttype)
|
||||
__field(__u32, parm)
|
||||
__field(__u64, parm64)
|
||||
__field(int, who)
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
@ -154,15 +162,12 @@ TRACE_EVENT(kvm_s390_inject_vcpu,
|
||||
__entry->inttype = type & 0x00000000ffffffff;
|
||||
__entry->parm = parm;
|
||||
__entry->parm64 = parm64;
|
||||
__entry->who = who;
|
||||
),
|
||||
|
||||
TP_printk("inject%s (vcpu %d): type:%x (%s) parm:%x parm64:%llx",
|
||||
(__entry->who == 1) ? " (from kernel)" :
|
||||
(__entry->who == 2) ? " (from user)" : "",
|
||||
TP_printk("inject (vcpu %d): type:%x (%s) parm:%x parm64:%llx",
|
||||
__entry->id, __entry->inttype,
|
||||
__print_symbolic(__entry->inttype, kvm_s390_int_type),
|
||||
__entry->parm, __entry->parm64)
|
||||
get_irq_name(__entry->inttype), __entry->parm,
|
||||
__entry->parm64)
|
||||
);
|
||||
|
||||
/*
|
||||
@ -189,8 +194,8 @@ TRACE_EVENT(kvm_s390_deliver_interrupt,
|
||||
TP_printk("deliver interrupt (vcpu %d): type:%x (%s) " \
|
||||
"data:%08llx %016llx",
|
||||
__entry->id, __entry->inttype,
|
||||
__print_symbolic(__entry->inttype, kvm_s390_int_type),
|
||||
__entry->data0, __entry->data1)
|
||||
get_irq_name(__entry->inttype), __entry->data0,
|
||||
__entry->data1)
|
||||
);
|
||||
|
||||
/*
|
||||
|
||||
@ -482,6 +482,7 @@ struct kvm_s390_psw {
|
||||
((ai) << 26))
|
||||
#define KVM_S390_INT_IO_MIN 0x00000000u
|
||||
#define KVM_S390_INT_IO_MAX 0xfffdffffu
|
||||
#define KVM_S390_INT_IO_AI_MASK 0x04000000u
|
||||
|
||||
|
||||
struct kvm_s390_interrupt {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user