Skip to contentSkip to conversation

KVM: s390: interrupt: Fix stepping into interrupt handlers

PATCH Superseded Ilya Leoshkevich 3 participants 15 messages Jul 21, 2023 – Jul 24, 2023

Subsystems (4)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover KVM: s390: interrupt: Fix stepping into interrupt handlers

v1: https://lore.kernel.org/lkml/[email protected]/
v1 -> v2: Fix three more issues.
Add selftests (Claudio).

Hi,

I tried to compare the behavior of KVM and TCG by diffing instruction traces, and found five issues in KVM related to stepping into interrupt handlers.

I'm not very familiar with the KVM code base, so please let me know if the fixes can be improved or if these problems need to be handled completely differently.

Best regards,
Ilya

Ilya Leoshkevich (6):
KVM: s390: interrupt: Fix single-stepping into interrupt handlers
KVM: s390: interrupt: Fix single-stepping into program interrupt
handlers
KVM: s390: interrupt: Fix single-stepping kernel-emulated instructions
KVM: s390: interrupt: Fix single-stepping userspace-emulated
instructions
KVM: s390: interrupt: Fix single-stepping ISKE
KVM: s390: selftests: Add selftest for single-stepping

 arch/s390/kvm/intercept.c                     |  39 ++++-
 arch/s390/kvm/interrupt.c                     |  10 ++
 arch/s390/kvm/kvm-s390.c                      |  20 ++-
 tools/testing/selftests/kvm/Makefile          |   1 +
 .../testing/selftests/kvm/s390x/debug_test.c  | 160 ++++++++++++++++++
 5 files changed, 218 insertions(+), 12 deletions(-)
 create mode 100644 tools/testing/selftests/kvm/s390x/debug_test.c
Signature · 1 line
2.41.0
#1 lore raw

PATCH v2 1/6 KVM: s390: interrupt: Fix single-stepping into interrupt handlers

After single-stepping an instruction that generates an interrupt, GDB ends up on the second instruction of the respective interrupt handler.

The reason is that vcpu_pre_run() manually delivers the interrupt, and then __vcpu_run() runs the first handler instruction using the CPUSTAT_P flag. This causes a KVM_SINGLESTEP exit on the second handler instruction.

Fix by delaying the KVM_SINGLESTEP exit until after the manual interrupt delivery.

---
 arch/s390/kvm/interrupt.c | 10 ++++++++++
 arch/s390/kvm/kvm-s390.c  |  4 ++--
 2 files changed, 12 insertions(+), 2 deletions(-)
arch/s390/kvm/interrupt.c +10 -0
index 9bd0a873f3b1..2cebe4227b8e 100644
@@ -1392,6 +1392,7 @@ int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
 {
 	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
 	int rc = 0;
+	bool delivered = false;
 	unsigned long irq_type;
 	unsigned long irqs;
 
@@ -1465,6 +1466,15 @@ int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
 			WARN_ONCE(1, "Unknown pending irq type %ld", irq_type);
 			clear_bit(irq_type, &li->pending_irqs);
 		}
+		delivered |= !rc;
+	}
+
+	if (delivered && guestdbg_sstep_enabled(vcpu)) {
+		struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;
+
+		debug_exit->addr = vcpu->arch.sie_block->gpsw.addr;
+		debug_exit->type = KVM_SINGLESTEP;
+		vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
 	}
 
 	set_intercept_indicators(vcpu);
arch/s390/kvm/kvm-s390.c +2 -2
index d1e768bcfe1d..0c6333b108ba 100644
@@ -4611,7 +4611,7 @@ static int vcpu_pre_run(struct kvm_vcpu *vcpu)
 
 	if (!kvm_is_ucontrol(vcpu->kvm)) {
 		rc = kvm_s390_deliver_pending_interrupts(vcpu);
-		if (rc)
+		if (rc || guestdbg_exit_pending(vcpu))
 			return rc;
 	}
 
@@ -4738,7 +4738,7 @@ static int __vcpu_run(struct kvm_vcpu *vcpu)
 
 	do {
 		rc = vcpu_pre_run(vcpu);
-		if (rc)
+		if (rc || guestdbg_exit_pending(vcpu))
 			break;
 
 		kvm_vcpu_srcu_read_unlock(vcpu);
Signature · 1 line
2.41.0
Acked-by on v2 1/6
#2 lore raw

Re: [PATCH v2 1/6] KVM: s390: interrupt: Fix single-stepping into interrupt handlers

Quoted 30 lines · Ilya Leoshkevich

After single-stepping an instruction that generates an interrupt, GDB ends up on the second instruction of the respective interrupt handler.

The reason is that vcpu_pre_run() manually delivers the interrupt, and then __vcpu_run() runs the first handler instruction using the CPUSTAT_P flag. This causes a KVM_SINGLESTEP exit on the second handler instruction.

Fix by delaying the KVM_SINGLESTEP exit until after the manual interrupt delivery.

---
  arch/s390/kvm/interrupt.c | 10 ++++++++++
  arch/s390/kvm/kvm-s390.c  |  4 ++--
  2 files changed, 12 insertions(+), 2 deletions(-)
arch/s390/kvm/interrupt.c +1 -0
index 9bd0a873f3b1..2cebe4227b8e 100644
@@ -1392,6 +1392,7 @@ int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
  {
  	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
  	int rc = 0;
+	bool delivered = false;
  	unsigned long irq_type;
  	unsigned long irqs;
 

arch/s390/kvm/interrupt.c int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu) · line 1471

Quoted 6 lines
arch/s390/kvm/interrupt.c +3 -0
@@ -1465,6 +1466,15 @@ int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
  			WARN_ONCE(1, "Unknown pending irq type %ld", irq_type);
  			clear_bit(irq_type, &li->pending_irqs);
  		}
+		delivered |= !rc;
+	}
+

Can we add a comment like

/*
* We delivered at least one interrupt and modified the PC. Force a
* singlestep event now.
*/

arch/s390/kvm/interrupt.c int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu) · line 1478

Quoted 7 lines
arch/s390/kvm/interrupt.c +6 -0
+	if (delivered && guestdbg_sstep_enabled(vcpu)) {
+		struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;
+
+		debug_exit->addr = vcpu->arch.sie_block->gpsw.addr;
+		debug_exit->type = KVM_SINGLESTEP;
+		vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
  	}

I do wonder if we, instead, want to do this whenever we modify the PSW.

That way we could catch any PC changes and only have to add checks for guestdbg_exit_pending().

But this is simpler and should work as well.

Signature · 3 lines
Cheers,

David / dhildenb
#3 lore raw

Re: [PATCH v2 1/6] KVM: s390: interrupt: Fix single-stepping into interrupt handlers

Quoted 21 lines · David Hildenbrand
Quoted 20 lines · Ilya Leoshkevich

After single-stepping an instruction that generates an interrupt, GDB
ends up on the second instruction of the respective interrupt handler.

The reason is that vcpu_pre_run() manually delivers the interrupt, and
then __vcpu_run() runs the first handler instruction using the CPUSTAT_P flag. This causes a KVM_SINGLESTEP exit on the second handler
instruction.

Fix by delaying the KVM_SINGLESTEP exit until after the manual interrupt delivery.

---
  arch/s390/kvm/interrupt.c | 10 ++++++++++
  arch/s390/kvm/kvm-s390.c  |  4 ++--

  2 files changed, 12 insertions(+), 2 deletions(-)

[...]

Quoted 8 lines

Can we add a comment like

/*
  * We delivered at least one interrupt and modified the PC. Force a
  * singlestep event now.
  */

Ok, will do.

Quoted 9 lines
Quoted 8 lines

+       if (delivered && guestdbg_sstep_enabled(vcpu)) { +               struct kvm_debug_exit_arch *debug_exit = &vcpu-

Quoted 1 line

run->debug.arch;

+
+               debug_exit->addr = vcpu->arch.sie_block->gpsw.addr; +               debug_exit->type = KVM_SINGLESTEP;
+               vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING; }

Quoted 6 lines

I do wonder if we, instead, want to do this whenever we modify the PSW.

That way we could catch any PC changes and only have to add checks for
guestdbg_exit_pending().

Wouldn't this break a corner case where the first instruction of the interrupt handler causes the same interrupt?

Quoted 3 lines

But this is simpler and should work as well.

#4 lore raw

Re: [PATCH v2 1/6] KVM: s390: interrupt: Fix single-stepping into interrupt handlers

Quoted 47 lines · Ilya Leoshkevich
Quoted 21 lines · David Hildenbrand
Quoted 20 lines · Ilya Leoshkevich

After single-stepping an instruction that generates an interrupt, GDB
ends up on the second instruction of the respective interrupt handler.

The reason is that vcpu_pre_run() manually delivers the interrupt, and
then __vcpu_run() runs the first handler instruction using the CPUSTAT_P flag. This causes a KVM_SINGLESTEP exit on the second handler
instruction.

Fix by delaying the KVM_SINGLESTEP exit until after the manual interrupt delivery.

---
   arch/s390/kvm/interrupt.c | 10 ++++++++++
   arch/s390/kvm/kvm-s390.c  |  4 ++--
   2 files changed, 12 insertions(+), 2 deletions(-)

[...]

Quoted 8 lines

Can we add a comment like

/*
  * We delivered at least one interrupt and modified the PC. Force a
  * singlestep event now.
  */

Ok, will do.

Quoted 12 lines
Quoted 8 lines

+       if (delivered && guestdbg_sstep_enabled(vcpu)) { +               struct kvm_debug_exit_arch *debug_exit = &vcpu-

Quoted 1 line

run->debug.arch;

+
+               debug_exit->addr = vcpu->arch.sie_block->gpsw.addr; +               debug_exit->type = KVM_SINGLESTEP;
+               vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
        }

I do wonder if we, instead, want to do this whenever we modify the PSW.

Quoted 6 lines
Quoted 3 lines

That way we could catch any PC changes and only have to add checks for
guestdbg_exit_pending().

Wouldn't this break a corner case where the first instruction of the interrupt handler causes the same interrupt?

Could be, there are many possible corner cases (PGM interrupt at the first instruction of PGM interrupt handler -- our PSW address might not even change)

Signature · 3 lines
Cheers,

David / dhildenb
#5 lore raw

PATCH v2 2/6 KVM: s390: interrupt: Fix single-stepping into program interrupt handlers

In reply to Ilya Leoshkevich

Currently, after single-stepping an instruction that generates a specification exception, GDB ends up on the instruction immediately following it.

The reason is that vcpu_post_run() injects the interrupt and sets KVM_GUESTDBG_EXIT_PENDING, causing a KVM_SINGLESTEP exit. The interrupt is not delivered, however, therefore userspace sees the address of the next instruction.

Fix by letting the __vcpu_run() loop go into the next iteration, where vcpu_pre_run() delivers the interrupt and sets KVM_GUESTDBG_EXIT_PENDING.

---
 arch/s390/kvm/intercept.c | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)
arch/s390/kvm/intercept.c +17 -2
index 954d39adf85c..7cdd927541b0 100644
@@ -226,7 +226,22 @@ static int handle_itdb(struct kvm_vcpu *vcpu)
 	return 0;
 }
 
-#define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
+static bool should_handle_per_event(const struct kvm_vcpu *vcpu)
+{
+	if (!guestdbg_enabled(vcpu))
+		return false;
+	if (!(vcpu->arch.sie_block->iprcc & PGM_PER))
+		return false;
+	if (guestdbg_sstep_enabled(vcpu) &&
+	    vcpu->arch.sie_block->iprcc != PGM_PER) {
+		/*
+		 * __vcpu_run() will exit after delivering the concurrently
+		 * indicated condition.
+		 */
+		return false;
+	}
+	return true;
+}
 
 static int handle_prog(struct kvm_vcpu *vcpu)
 {
@@ -242,7 +257,7 @@ static int handle_prog(struct kvm_vcpu *vcpu)
 	if (kvm_s390_pv_cpu_is_protected(vcpu))
 		return -EOPNOTSUPP;
 
-	if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
+	if (should_handle_per_event(vcpu)) {
 		rc = kvm_s390_handle_per_event(vcpu);
 		if (rc)
 			return rc;
Signature · 1 line
2.41.0
Reviewed-by on v2 2/6
#6 lore raw

Re: [PATCH v2 2/6] KVM: s390: interrupt: Fix single-stepping into program interrupt handlers

Quoted 47 lines · Ilya Leoshkevich

Currently, after single-stepping an instruction that generates a specification exception, GDB ends up on the instruction immediately following it.

The reason is that vcpu_post_run() injects the interrupt and sets KVM_GUESTDBG_EXIT_PENDING, causing a KVM_SINGLESTEP exit. The interrupt is not delivered, however, therefore userspace sees the address of the next instruction.

Fix by letting the __vcpu_run() loop go into the next iteration, where vcpu_pre_run() delivers the interrupt and sets KVM_GUESTDBG_EXIT_PENDING.

---
  arch/s390/kvm/intercept.c | 19 +++++++++++++++++--
  1 file changed, 17 insertions(+), 2 deletions(-)
arch/s390/kvm/intercept.c +16 -1
index 954d39adf85c..7cdd927541b0 100644
@@ -226,7 +226,22 @@ static int handle_itdb(struct kvm_vcpu *vcpu)
  	return 0;
  }
 
-#define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
+static bool should_handle_per_event(const struct kvm_vcpu *vcpu)
+{
+	if (!guestdbg_enabled(vcpu))
+		return false;
+	if (!(vcpu->arch.sie_block->iprcc & PGM_PER))
+		return false;
+	if (guestdbg_sstep_enabled(vcpu) &&
+	    vcpu->arch.sie_block->iprcc != PGM_PER) {
+		/*
+		 * __vcpu_run() will exit after delivering the concurrently
+		 * indicated condition.
+		 */
+		return false;
+	}
+	return true;
+}
 
  static int handle_prog(struct kvm_vcpu *vcpu)
  {

arch/s390/kvm/intercept.c static int handle_prog(struct kvm_vcpu *vcpu) · line 263

Quoted 8 lines
arch/s390/kvm/intercept.c +1 -1
@@ -242,7 +257,7 @@ static int handle_prog(struct kvm_vcpu *vcpu)
  	if (kvm_s390_pv_cpu_is_protected(vcpu))
  		return -EOPNOTSUPP;
 
-	if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
+	if (should_handle_per_event(vcpu)) {
  		rc = kvm_s390_handle_per_event(vcpu);
  		if (rc)
  			return rc;
Signature · 3 lines
Cheers,

David / dhildenb
#7 lore raw

PATCH v2 3/6 KVM: s390: interrupt: Fix single-stepping kernel-emulated instructions

In reply to Ilya Leoshkevich

Single-stepping a kernel-emulated instruction that generates an interrupt causes GDB to land on the instruction following it instead of the respective interrupt handler.

The reason is that kvm_handle_sie_intercept(), after injecting the interrupt, also processes the PER event and arranges a KVM_SINGLESTEP exit. The interrupt is not yet delivered, however, so the userspace sees the next instruction.

Fix by avoiding the KVM_SINGLESTEP exit when there is a pending interrupt. The next __vcpu_run() loop iteration will arrange a KVM_SINGLESTEP exit after delivering the interrupt.

---
 arch/s390/kvm/intercept.c | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)
arch/s390/kvm/intercept.c +14 -3
index 7cdd927541b0..d2f7940c5d03 100644
@@ -583,6 +583,19 @@ static int handle_pv_notification(struct kvm_vcpu *vcpu)
 	return handle_instruction(vcpu);
 }
 
+static bool should_handle_per_ifetch(const struct kvm_vcpu *vcpu, int rc)
+{
+	/* Process PER, also if the instruction is processed in user space. */
+	if (!(vcpu->arch.sie_block->icptstatus & 0x02))
+		return false;
+	if (rc != 0 && rc != -EOPNOTSUPP)
+		return false;
+	if (guestdbg_sstep_enabled(vcpu) && vcpu->arch.local_int.pending_irqs)
+		/* __vcpu_run() will exit after delivering the interrupt. */
+		return false;
+	return true;
+}
+
 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
 {
 	int rc, per_rc = 0;
@@ -645,9 +658,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
 		return -EOPNOTSUPP;
 	}
 
-	/* process PER, also if the instruction is processed in user space */
-	if (vcpu->arch.sie_block->icptstatus & 0x02 &&
-	    (!rc || rc == -EOPNOTSUPP))
+	if (should_handle_per_ifetch(vcpu, rc))
 		per_rc = kvm_s390_handle_per_ifetch_icpt(vcpu);
 	return per_rc ? per_rc : rc;
 }
Signature · 1 line
2.41.0
Reviewed-by on v2 3/6
#8 lore raw

Re: [PATCH v2 3/6] KVM: s390: interrupt: Fix single-stepping kernel-emulated instructions

Quoted 43 lines · Ilya Leoshkevich

Single-stepping a kernel-emulated instruction that generates an interrupt causes GDB to land on the instruction following it instead of the respective interrupt handler.

The reason is that kvm_handle_sie_intercept(), after injecting the interrupt, also processes the PER event and arranges a KVM_SINGLESTEP exit. The interrupt is not yet delivered, however, so the userspace sees the next instruction.

Fix by avoiding the KVM_SINGLESTEP exit when there is a pending interrupt. The next __vcpu_run() loop iteration will arrange a KVM_SINGLESTEP exit after delivering the interrupt.

---
  arch/s390/kvm/intercept.c | 17 ++++++++++++++---
  1 file changed, 14 insertions(+), 3 deletions(-)
arch/s390/kvm/intercept.c +13 -0
index 7cdd927541b0..d2f7940c5d03 100644
@@ -583,6 +583,19 @@ static int handle_pv_notification(struct kvm_vcpu *vcpu)
  	return handle_instruction(vcpu);
  }
 
+static bool should_handle_per_ifetch(const struct kvm_vcpu *vcpu, int rc)
+{
+	/* Process PER, also if the instruction is processed in user space. */
+	if (!(vcpu->arch.sie_block->icptstatus & 0x02))
+		return false;
+	if (rc != 0 && rc != -EOPNOTSUPP)
+		return false;
+	if (guestdbg_sstep_enabled(vcpu) && vcpu->arch.local_int.pending_irqs)
+		/* __vcpu_run() will exit after delivering the interrupt. */
+		return false;
+	return true;
+}
+
  int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
  {
  	int rc, per_rc = 0;

arch/s390/kvm/intercept.c int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu) · line 664

Quoted 10 lines
arch/s390/kvm/intercept.c +1 -3
@@ -645,9 +658,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
  		return -EOPNOTSUPP;
  	}
 
-	/* process PER, also if the instruction is processed in user space */
-	if (vcpu->arch.sie_block->icptstatus & 0x02 &&
-	    (!rc || rc == -EOPNOTSUPP))
+	if (should_handle_per_ifetch(vcpu, rc))
  		per_rc = kvm_s390_handle_per_ifetch_icpt(vcpu);
  	return per_rc ? per_rc : rc;
  }
Signature · 3 lines
Cheers,

David / dhildenb
#9 lore raw

PATCH v2 4/6 KVM: s390: interrupt: Fix single-stepping userspace-emulated instructions

In reply to Ilya Leoshkevich

Single-stepping a userspace-emulated instruction that generates an interrupt causes GDB to land on the instruction following it instead of the respective interrupt handler.

The reason is that after arranging a KVM_EXIT_S390_SIEIC exit, kvm_handle_sie_intercept() calls kvm_s390_handle_per_ifetch_icpt(), which sets KVM_GUESTDBG_EXIT_PENDING. This bit, however, is not processed immediately, but rather persists until the next ioctl(), causing a spurious single-step exit.

Fix by clearing this bit before KVM_EXIT_S390_SIEIC.

---
 arch/s390/kvm/kvm-s390.c | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)
arch/s390/kvm/kvm-s390.c +13 -3
index 0c6333b108ba..b717fb8cffed 100644
@@ -5383,6 +5383,7 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,
 {
 	struct kvm_vcpu *vcpu = filp->private_data;
 	void __user *argp = (void __user *)arg;
+	int rc;
 
 	switch (ioctl) {
 	case KVM_S390_IRQ: {
@@ -5390,7 +5391,8 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,
 
 		if (copy_from_user(&s390irq, argp, sizeof(s390irq)))
 			return -EFAULT;
-		return kvm_s390_inject_vcpu(vcpu, &s390irq);
+		rc = kvm_s390_inject_vcpu(vcpu, &s390irq);
+		break;
 	}
 	case KVM_S390_INTERRUPT: {
 		struct kvm_s390_interrupt s390int;
@@ -5400,10 +5402,18 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,
 			return -EFAULT;
 		if (s390int_to_s390irq(&s390int, &s390irq))
 			return -EINVAL;
-		return kvm_s390_inject_vcpu(vcpu, &s390irq);
+		rc = kvm_s390_inject_vcpu(vcpu, &s390irq);
+		break;
 	}
+	default:
+		rc = -ENOIOCTLCMD;
+		break;
 	}
-	return -ENOIOCTLCMD;
+
+	if (!rc)
+		vcpu->guest_debug &= ~KVM_GUESTDBG_EXIT_PENDING;
+
+	return rc;
 }
 
 static int kvm_s390_handle_pv_vcpu_dump(struct kvm_vcpu *vcpu,
Signature · 1 line
2.41.0
#10 lore raw

Re: [PATCH v2 4/6] KVM: s390: interrupt: Fix single-stepping userspace-emulated instructions

arch/s390/kvm/kvm-s390.c long kvm_arch_vcpu_async_ioctl(struct file *filp, · line 5412

Quoted 5 lines
arch/s390/kvm/kvm-s390.c +3 -1
+		rc = -ENOIOCTLCMD;
+		break;
  	}
-	return -ENOIOCTLCMD;
+

This really needs a comment. :)

Quoted 7 lines
arch/s390/kvm/kvm-s390.c +4 -0
+	if (!rc)
+		vcpu->guest_debug &= ~KVM_GUESTDBG_EXIT_PENDING;
+
+	return rc;
  }
 
  static int kvm_s390_handle_pv_vcpu_dump(struct kvm_vcpu *vcpu,
Signature · 3 lines
Cheers,

David / dhildenb
#11 lore raw

PATCH v2 5/6 KVM: s390: interrupt: Fix single-stepping ISKE

In reply to Ilya Leoshkevich

kvm_s390_skey_check_enable() does not emulate any instructions, rather, it clears CPUSTAT_KSS and arranges for ISKE to run again. Therefore, skip the PER check and let ISKE run happen. Otherwise a debugger will see two single-step events on the same ISKE.

---
 arch/s390/kvm/intercept.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
arch/s390/kvm/intercept.c +1 -2
index d2f7940c5d03..8793cec066a6 100644
@@ -630,8 +630,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
 		rc = handle_partial_execution(vcpu);
 		break;
 	case ICPT_KSS:
-		rc = kvm_s390_skey_check_enable(vcpu);
-		break;
+		return kvm_s390_skey_check_enable(vcpu);
 	case ICPT_MCHKREQ:
 	case ICPT_INT_ENABLE:
 		/*
Signature · 1 line
2.41.0
maintainer Reviewed-by on v2 5/6
#12 lore raw

Re: [PATCH v2 5/6] KVM: s390: interrupt: Fix single-stepping ISKE

Am 21.07.23 um 13:57 schrieb Ilya Leoshkevich:

Quoted 4 lines

kvm_s390_skey_check_enable() does not emulate any instructions, rather, it clears CPUSTAT_KSS and arranges for ISKE to run again. Therefore, skip the PER check and let ISKE run happen. Otherwise a debugger will see two single-step events on the same ISKE.

The same would be true for all instruction triggering a keyless mode exit, like SSKE, RRBE but also LPSWE with a keyed PSW, no?

Quoted 2 lines
Quoted 9 lines
---
  arch/s390/kvm/intercept.c | 3 +--
  1 file changed, 1 insertion(+), 2 deletions(-)
arch/s390/kvm/intercept.c +0 -0
index d2f7940c5d03..8793cec066a6 100644

arch/s390/kvm/intercept.c int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu) · line 634

Quoted 5 lines
arch/s390/kvm/intercept.c +0 -2
@@ -630,8 +630,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
  		rc = handle_partial_execution(vcpu);
  		break;
  	case ICPT_KSS:
-		rc = kvm_s390_skey_check_enable(vcpu);
-		break;

maybe add a comment here: /* Instruction will be redriven, skip the PER check */

Quoted 5 lines
arch/s390/kvm/intercept.c +1 -0
+		return kvm_s390_skey_check_enable(vcpu);
 
  	case ICPT_MCHKREQ:
  	case ICPT_INT_ENABLE:

/*

Reviewed-by on v2 5/6
#13 lore raw

Re: [PATCH v2 5/6] KVM: s390: interrupt: Fix single-stepping ISKE

In reply to Ilya Leoshkevich
Quoted 15 lines · Ilya Leoshkevich

kvm_s390_skey_check_enable() does not emulate any instructions, rather, it clears CPUSTAT_KSS and arranges for ISKE to run again. Therefore, skip the PER check and let ISKE run happen. Otherwise a debugger will see two single-step events on the same ISKE.

---
  arch/s390/kvm/intercept.c | 3 +--
  1 file changed, 1 insertion(+), 2 deletions(-)
arch/s390/kvm/intercept.c +0 -0
index d2f7940c5d03..8793cec066a6 100644

arch/s390/kvm/intercept.c int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu) · line 636

Quoted 9 lines
arch/s390/kvm/intercept.c +1 -2
@@ -630,8 +630,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
  		rc = handle_partial_execution(vcpu);
  		break;
  	case ICPT_KSS:
-		rc = kvm_s390_skey_check_enable(vcpu);
-		break;
+		return kvm_s390_skey_check_enable(vcpu);
  	case ICPT_MCHKREQ:
  	case ICPT_INT_ENABLE:
  		/*
Signature · 3 lines
Cheers,

David / dhildenb
#14 lore raw

PATCH v2 6/6 KVM: s390: selftests: Add selftest for single-stepping

In reply to Ilya Leoshkevich

Test different variations of single-stepping into interrupts:

- SVC and PGM interrupts;
- Interrupts generated by ISKE;
- Interrupts generated by instructions emulated by KVM;
- Interrupts generated by instructions emulated by userspace.

---
 tools/testing/selftests/kvm/Makefile          |   1 +
 .../testing/selftests/kvm/s390x/debug_test.c  | 160 ++++++++++++++++++
 2 files changed, 161 insertions(+)
 create mode 100644 tools/testing/selftests/kvm/s390x/debug_test.c
tools/testing/selftests/kvm/Makefile +1 -0
index c692cc86e7da..f3306eaa7031 100644
@@ -166,6 +166,7 @@ TEST_GEN_PROGS_s390x += s390x/resets
 TEST_GEN_PROGS_s390x += s390x/sync_regs_test
 TEST_GEN_PROGS_s390x += s390x/tprot
 TEST_GEN_PROGS_s390x += s390x/cmma_test
+TEST_GEN_PROGS_s390x += s390x/debug_test
 TEST_GEN_PROGS_s390x += demand_paging_test
 TEST_GEN_PROGS_s390x += dirty_log_test
 TEST_GEN_PROGS_s390x += kvm_create_max_vcpus
tools/testing/selftests/kvm/s390x/debug_test.c new file +160 -0

160 lines not on this page · raw message

Signature · 1 line
2.41.0