KVM: s390: hardware support for guest debugging

This patch adds support to debug the guest using the PER facility on s390.
Single-stepping, hardware breakpoints and hardware watchpoints are supported. In
order to use the PER facility of the guest without it noticing it, the control
registers of the guest have to be patched and access to them has to be
intercepted(stctl, stctg, lctl, lctlg).

All PER program interrupts have to be intercepted and only the relevant PER
interrupts for the guest have to be given back. Special care has to be taken
about repeated exits on the same hardware breakpoint. The intervention of the
host in the guests PER configuration is not fully transparent. PER instruction
nullification can not be used by the guest and too many storage alteration
events may be reported to the guest (if it is activated for special address
ranges only) when the host concurrently debugging it.

Signed-off-by: David Hildenbrand <dahi@linux.vnet.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>

1 files changed, 51 insertions, 2 deletions

diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index 7ae8c26065fb..e6bbfe1a9474 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -934,10 +934,40 @@ int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
         return -EINVAL; /* not implemented yet */
 }
 
+#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
+                              KVM_GUESTDBG_USE_HW_BP | \
+                              KVM_GUESTDBG_ENABLE)
+
 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
                                         struct kvm_guest_debug *dbg)
 {
-        return -EINVAL; /* not implemented yet */
+        int rc = 0;
+
+        vcpu->guest_debug = 0;
+        kvm_s390_clear_bp_data(vcpu);
+
+        if (vcpu->guest_debug & ~VALID_GUESTDBG_FLAGS)
+                return -EINVAL;
+
+        if (dbg->control & KVM_GUESTDBG_ENABLE) {
+                vcpu->guest_debug = dbg->control;
+                /* enforce guest PER */
+                atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+
+                if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
+                        rc = kvm_s390_import_bp_data(vcpu, dbg);
+        } else {
+                atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+                vcpu->arch.guestdbg.last_bp = 0;
+        }
+
+        if (rc) {
+                vcpu->guest_debug = 0;
+                kvm_s390_clear_bp_data(vcpu);
+                atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+        }
+
+        return rc;
 }
 
 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
@@ -1095,6 +1125,11 @@ static int vcpu_pre_run(struct kvm_vcpu *vcpu)
         if (rc)
                 return rc;
 
+        if (guestdbg_enabled(vcpu)) {
+                kvm_s390_backup_guest_per_regs(vcpu);
+                kvm_s390_patch_guest_per_regs(vcpu);
+        }
+
         vcpu->arch.sie_block->icptcode = 0;
         cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
         VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
@@ -1111,6 +1146,9 @@ static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
                    vcpu->arch.sie_block->icptcode);
         trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
 
+        if (guestdbg_enabled(vcpu))
+                kvm_s390_restore_guest_per_regs(vcpu);
+
         if (exit_reason >= 0) {
                 rc = 0;
         } else if (kvm_is_ucontrol(vcpu->kvm)) {
@@ -1176,7 +1214,7 @@ static int __vcpu_run(struct kvm_vcpu *vcpu)
                 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
 
                 rc = vcpu_post_run(vcpu, exit_reason);
-        } while (!signal_pending(current) && !rc);
+        } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
 
         srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
         return rc;
@@ -1187,6 +1225,11 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         int rc;
         sigset_t sigsaved;
 
+        if (guestdbg_exit_pending(vcpu)) {
+                kvm_s390_prepare_debug_exit(vcpu);
+                return 0;
+        }
+
         if (vcpu->sigset_active)
                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 
@@ -1199,6 +1242,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         case KVM_EXIT_S390_RESET:
         case KVM_EXIT_S390_UCONTROL:
         case KVM_EXIT_S390_TSCH:
+        case KVM_EXIT_DEBUG:
                 break;
         default:
                 BUG();
@@ -1224,6 +1268,11 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 rc = -EINTR;
         }
 
+        if (guestdbg_exit_pending(vcpu) && !rc)  {
+                kvm_s390_prepare_debug_exit(vcpu);
+                rc = 0;
+        }
+
         if (rc == -EOPNOTSUPP) {
                 /* intercept cannot be handled in-kernel, prepare kvm-run */
                 kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;