Merge tag 'kvm-4.3-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm

Pull kvm updates from Paolo Bonzini:
 "A very small release for x86 and s390 KVM.

   - s390: timekeeping changes, cleanups and fixes

   - x86: support for Hyper-V MSRs to report crashes, and a bunch of
     cleanups.

  One interesting feature that was planned for 4.3 (emulating the local
  APIC in kernel while keeping the IOAPIC and 8254 in userspace) had to
  be delayed because Intel complained about my reading of the manual"

* tag 'kvm-4.3-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (42 commits)
  x86/kvm: Rename VMX's segment access rights defines
  KVM: x86/vPMU: Fix unnecessary signed extension for AMD PERFCTRn
  kvm: x86: Fix error handling in the function kvm_lapic_sync_from_vapic
  KVM: s390: Fix assumption that kvm_set_irq_routing is always run successfully
  KVM: VMX: drop ept misconfig check
  KVM: MMU: fully check zero bits for sptes
  KVM: MMU: introduce is_shadow_zero_bits_set()
  KVM: MMU: introduce the framework to check zero bits on sptes
  KVM: MMU: split reset_rsvds_bits_mask_ept
  KVM: MMU: split reset_rsvds_bits_mask
  KVM: MMU: introduce rsvd_bits_validate
  KVM: MMU: move FNAME(is_rsvd_bits_set) to mmu.c
  KVM: MMU: fix validation of mmio page fault
  KVM: MTRR: Use default type for non-MTRR-covered gfn before WARN_ON
  KVM: s390: host STP toleration for VMs
  KVM: x86: clean/fix memory barriers in irqchip_in_kernel
  KVM: document memory barriers for kvm->vcpus/kvm->online_vcpus
  KVM: x86: remove unnecessary memory barriers for shared MSRs
  KVM: move code related to KVM_SET_BOOT_CPU_ID to x86
  KVM: s390: log capability enablement and vm attribute changes
  ...

8 files changed, 240 insertions, 105 deletions

diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c
index fc7ec95848c3..5fbfb88f8477 100644
--- a/arch/s390/kvm/diag.c
+++ b/arch/s390/kvm/diag.c
@@ -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))
diff --git a/arch/s390/kvm/guestdbg.c b/arch/s390/kvm/guestdbg.c
index e97b3455d7e6..47518a324d75 100644
--- a/arch/s390/kvm/guestdbg.c
+++ b/arch/s390/kvm/guestdbg.c
@@ -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;
+        }
 }
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index c98d89708e99..b277d50dcf76 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -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
@@ -72,9 +71,13 @@ static int ckc_interrupts_enabled(struct kvm_vcpu *vcpu)
 
 static int ckc_irq_pending(struct kvm_vcpu *vcpu)
 {
+        preempt_disable();
         if (!(vcpu->arch.sie_block->ckc <
-              get_tod_clock_fast() + vcpu->arch.sie_block->epoch))
+              get_tod_clock_fast() + vcpu->arch.sie_block->epoch)) {
+                preempt_enable();
                 return 0;
+        }
+        preempt_enable();
         return ckc_interrupts_enabled(vcpu);
 }
 
@@ -311,8 +314,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 +371,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 +406,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 +430,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 +452,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 +479,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 +508,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 +624,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 +653,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 +661,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 +696,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 +746,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,
@@ -855,7 +860,9 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
                 goto no_timer;
         }
 
+        preempt_disable();
         now = get_tod_clock_fast() + vcpu->arch.sie_block->epoch;
+        preempt_enable();
         sltime = tod_to_ns(vcpu->arch.sie_block->ckc - now);
 
         /* underflow */
@@ -864,7 +871,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);
@@ -894,7 +901,9 @@ enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer)
         u64 now, sltime;
 
         vcpu = container_of(timer, struct kvm_vcpu, arch.ckc_timer);
+        preempt_disable();
         now = get_tod_clock_fast() + vcpu->arch.sie_block->epoch;
+        preempt_enable();
         sltime = tod_to_ns(vcpu->arch.sie_block->ckc - now);
 
         /*
@@ -968,6 +977,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 +991,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 +1006,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 +1018,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 +1051,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 +1076,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 +1096,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 +1120,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 +1132,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 +1148,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 +1178,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 +1191,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 +1441,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 +1541,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:
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index f32f843a3631..6861b74649ae 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -28,6 +28,7 @@
 #include <linux/vmalloc.h>
 #include <asm/asm-offsets.h>
 #include <asm/lowcore.h>
+#include <asm/etr.h>
 #include <asm/pgtable.h>
 #include <asm/nmi.h>
 #include <asm/switch_to.h>
@@ -108,6 +109,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 +128,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)
@@ -134,24 +139,69 @@ int kvm_arch_hardware_enable(void)
 
 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
 
+/*
+ * 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->arch.epoch -= *delta;
+                kvm_for_each_vcpu(i, vcpu, kvm) {
+                        vcpu->arch.sie_block->epoch -= *delta;
+                }
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block kvm_clock_notifier = {
+        .notifier_call = kvm_clock_sync,
+};
+
 int kvm_arch_hardware_setup(void)
 {
         gmap_notifier.notifier_call = kvm_gmap_notifier;
         gmap_register_ipte_notifier(&gmap_notifier);
+        atomic_notifier_chain_register(&s390_epoch_delta_notifier,
+                                       &kvm_clock_notifier);
         return 0;
 }
 
 void kvm_arch_hardware_unsetup(void)
 {
         gmap_unregister_ipte_notifier(&gmap_notifier);
+        atomic_notifier_chain_unregister(&s390_epoch_delta_notifier,
+                                         &kvm_clock_notifier);
 }
 
 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 +331,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 +347,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 +369,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 +387,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 +402,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 +442,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 +469,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 +513,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;
 }
@@ -459,12 +533,15 @@ static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
                 return r;
 
         mutex_lock(&kvm->lock);
+        preempt_disable();
         kvm->arch.epoch = gtod - host_tod;
         kvm_s390_vcpu_block_all(kvm);
         kvm_for_each_vcpu(vcpu_idx, cur_vcpu, kvm)
                 cur_vcpu->arch.sie_block->epoch = kvm->arch.epoch;
         kvm_s390_vcpu_unblock_all(kvm);
+        preempt_enable();
         mutex_unlock(&kvm->lock);
+        VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx\n", gtod);
         return 0;
 }
 
@@ -496,6 +573,7 @@ static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
         if (copy_to_user((void __user *)attr->addr, &gtod_high,
                                          sizeof(gtod_high)))
                 return -EFAULT;
+        VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x\n", gtod_high);
 
         return 0;
 }
@@ -509,9 +587,12 @@ static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
         if (r)
                 return r;
 
+        preempt_disable();
         gtod = host_tod + kvm->arch.epoch;
+        preempt_enable();
         if (copy_to_user((void __user *)attr->addr, &gtod, sizeof(gtod)))
                 return -EFAULT;
+        VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx\n", gtod);
 
         return 0;
 }
@@ -821,7 +902,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);
@@ -879,8 +962,7 @@ long kvm_arch_vm_ioctl(struct file *filp,
                 if (kvm->arch.use_irqchip) {
                         /* Set up dummy routing. */
                         memset(&routing, 0, sizeof(routing));
-                        kvm_set_irq_routing(kvm, &routing, 0, 0);
-                        r = 0;
+                        r = kvm_set_irq_routing(kvm, &routing, 0, 0);
                 }
                 break;
         }
@@ -1043,7 +1125,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 +1168,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 +1185,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 +1193,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 +1215,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 +1250,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 */
@@ -1264,7 +1349,9 @@ static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
 void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
 {
         mutex_lock(&vcpu->kvm->lock);
+        preempt_disable();
         vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch;
+        preempt_enable();
         mutex_unlock(&vcpu->kvm->lock);
         if (!kvm_is_ucontrol(vcpu->kvm))
                 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
@@ -1342,7 +1429,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 +1810,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 +2415,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;
diff --git a/arch/s390/kvm/kvm-s390.h b/arch/s390/kvm/kvm-s390.h
index c5704786e473..c446aabf60d3 100644
--- a/arch/s390/kvm/kvm-s390.h
+++ b/arch/s390/kvm/kvm-s390.h
@@ -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[];
 
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index ad4242245771..4d21dc4d1a84 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -53,11 +53,14 @@ 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);
+        preempt_disable();
         kvm_for_each_vcpu(i, cpup, vcpu->kvm)
                 cpup->arch.sie_block->epoch = val;
+        preempt_enable();
         mutex_unlock(&vcpu->kvm->lock);
 
         kvm_s390_set_psw_cc(vcpu, 0);
@@ -98,8 +101,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 +130,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 +156,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 +168,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 +372,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 +470,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 +523,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 +760,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 +831,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 +870,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 +904,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 +942,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;
diff --git a/arch/s390/kvm/sigp.c b/arch/s390/kvm/sigp.c
index 72e58bd2bee7..da690b69f9fe 100644
--- a/arch/s390/kvm/sigp.c
+++ b/arch/s390/kvm/sigp.c
@@ -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)
diff --git a/arch/s390/kvm/trace-s390.h b/arch/s390/kvm/trace-s390.h
index 3208d33a48cb..cc1d6c68356f 100644
--- a/arch/s390/kvm/trace-s390.h
+++ b/arch/s390/kvm/trace-s390.h
@@ -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)
         );
 
 /*