Skip to contentSkip to conversation

x86/cpu: Add Bus Lock Detect support for AMD

PATCH Superseded Ravi Bangoria 5 participants 19 messages Apr 29, 2024 – Jul 11, 2024

Subsystems (3)

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

cover x86/cpu: Add Bus Lock Detect support for AMD

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Add support for the same in Linux. Bus Lock Detect is enumerated with cpuid CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

Patches are prepared on tip/x86/cpu (e063b531d4e8)

Patch #3 depends on SEV-ES LBRV fix:
https://lore.kernel.org/r/[email protected]

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653

Ravi Bangoria (3):
x86/split_lock: Move Split and Bus lock code to a dedicated file x86/bus_lock: Add support for AMD
KVM SVM: Add Bus Lock Detect support

 arch/x86/include/asm/cpu.h           |   4 +
 arch/x86/kernel/cpu/Makefile         |   1 +
 arch/x86/kernel/cpu/amd.c            |   2 +
 arch/x86/kernel/cpu/intel.c          | 407 ---------------------------
 arch/x86/kernel/cpu/split-bus-lock.c | 406 ++++++++++++++++++++++++++
 arch/x86/kvm/svm/nested.c            |   3 +-
 arch/x86/kvm/svm/svm.c               |  16 +-
 7 files changed, 430 insertions(+), 409 deletions(-)
 create mode 100644 arch/x86/kernel/cpu/split-bus-lock.c
Signature · 1 line
2.44.0
#1 lore raw

PATCH 1/3 x86/split_lock: Move Split and Bus lock code to a dedicated file

Upcoming AMD uarch will support Bus Lock Detect, which functionally works identical to Intel. Move split_lock and bus_lock specific code from intel.c to a dedicated file so that it can be compiled and supported on non-intel platforms.

---
 arch/x86/include/asm/cpu.h           |   4 +
 arch/x86/kernel/cpu/Makefile         |   1 +
 arch/x86/kernel/cpu/intel.c          | 407 ---------------------------
 arch/x86/kernel/cpu/split-bus-lock.c | 406 ++++++++++++++++++++++++++
 4 files changed, 411 insertions(+), 407 deletions(-)
 create mode 100644 arch/x86/kernel/cpu/split-bus-lock.c
arch/x86/include/asm/cpu.h +4 -0
index aa30fd8cad7f..4b5c31dc8112 100644
@@ -51,6 +51,10 @@ static inline u8 get_this_hybrid_cpu_type(void)
 	return 0;
 }
 #endif
+
+void split_lock_init(void);
+void bus_lock_init(void);
+
 #ifdef CONFIG_IA32_FEAT_CTL
 void init_ia32_feat_ctl(struct cpuinfo_x86 *c);
 #else
arch/x86/kernel/cpu/Makefile +1 -0
index eb4dbcdf41f1..86a10472ad1d 100644
@@ -27,6 +27,7 @@ obj-y			+= aperfmperf.o
 obj-y			+= cpuid-deps.o
 obj-y			+= umwait.o
 obj-y 			+= capflags.o powerflags.o
+obj-y 			+= split-bus-lock.o
 
 obj-$(CONFIG_X86_LOCAL_APIC)		+= topology.o
 
arch/x86/kernel/cpu/intel.c +0 -407

440 lines not on this page · raw message

arch/x86/kernel/cpu/split-bus-lock.c new file +406 -0

406 lines not on this page · raw message

Signature · 1 line
2.44.0
maintainer
#2 lore raw

Re: [PATCH 1/3] x86/split_lock: Move Split and Bus lock code to a dedicated file

Quoted 34 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect, which functionally works identical to Intel. Move split_lock and bus_lock specific code from intel.c to a dedicated file so that it can be compiled and supported on non-intel platforms.

---
 arch/x86/include/asm/cpu.h           |   4 +
 arch/x86/kernel/cpu/Makefile         |   1 +
 arch/x86/kernel/cpu/intel.c          | 407 ---------------------------
 arch/x86/kernel/cpu/split-bus-lock.c | 406 ++++++++++++++++++++++++++
 4 files changed, 411 insertions(+), 407 deletions(-)
 create mode 100644 arch/x86/kernel/cpu/split-bus-lock.c
arch/x86/include/asm/cpu.h +4 -0
index aa30fd8cad7f..4b5c31dc8112 100644
@@ -51,6 +51,10 @@ static inline u8 get_this_hybrid_cpu_type(void)
 	return 0;
 }
 #endif
+
+void split_lock_init(void);
+void bus_lock_init(void);
+
 #ifdef CONFIG_IA32_FEAT_CTL
 void init_ia32_feat_ctl(struct cpuinfo_x86 *c);
 #else
arch/x86/kernel/cpu/Makefile +0 -0
index eb4dbcdf41f1..86a10472ad1d 100644

arch/x86/kernel/cpu/Makefile obj-y += aperfmperf.o · line 30

Quoted 4 lines
arch/x86/kernel/cpu/Makefile +1 -0
@@ -27,6 +27,7 @@ obj-y			+= aperfmperf.o
 obj-y			+= cpuid-deps.o
 obj-y			+= umwait.o
 obj-y 			+= capflags.o powerflags.o
+obj-y 			+= split-bus-lock.o

Too fine-grained a name and those "-" should be "_".

Perhaps bus_lock.c only...

Signature · 4 lines
Regards/Gruss,
    Boris.

https://people.kernel.org/tglx/notes-about-netiquette
#3 lore raw

Re: [PATCH 1/3] x86/split_lock: Move Split and Bus lock code to a dedicated file

Quoted 12 lines

arch/x86/kernel/cpu/Makefile obj-y += aperfmperf.o · line 30

Quoted 9 lines
arch/x86/kernel/cpu/Makefile +1 -0
index eb4dbcdf41f1..86a10472ad1d 100644
@@ -27,6 +27,7 @@ obj-y			+= aperfmperf.o
 obj-y			+= cpuid-deps.o
 obj-y			+= umwait.o
 obj-y 			+= capflags.o powerflags.o
+obj-y 			+= split-bus-lock.o

Too fine-grained a name and those "-" should be "_".

Quoted 1 line

Perhaps bus_lock.c only...

Sure, will rename it to bus_lock.c

Thanks,
Ravi

#4 lore raw

PATCH 2/3 x86/bus_lock: Add support for AMD

In reply to Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Add support for the same in Linux. Bus Lock Detect is enumerated with cpuid CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653
---
 arch/x86/kernel/cpu/amd.c | 2 ++
 1 file changed, 2 insertions(+)
arch/x86/kernel/cpu/amd.c +2 -0
index 39f316d50ae4..013d16479a24 100644
@@ -1058,6 +1058,8 @@ static void init_amd(struct cpuinfo_x86 *c)
 
 	/* AMD CPUs don't need fencing after x2APIC/TSC_DEADLINE MSR writes. */
 	clear_cpu_cap(c, X86_FEATURE_APIC_MSRS_FENCE);
+
+	bus_lock_init();
 }
 
 #ifdef CONFIG_X86_32
Signature · 1 line
2.44.0
#5 lore raw

Re: [PATCH 2/3] x86/bus_lock: Add support for AMD

Quoted 21 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Add support for the same in Linux. Bus Lock Detect is enumerated with cpuid CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

      2023, Vol 2, 13.1.3.6 Bus Lock Trap
      https://bugzilla.kernel.org/attachment.cgi?id=304653
---
  arch/x86/kernel/cpu/amd.c | 2 ++
  1 file changed, 2 insertions(+)
arch/x86/kernel/cpu/amd.c +0 -0
index 39f316d50ae4..013d16479a24 100644

arch/x86/kernel/cpu/amd.c static void init_amd(struct cpuinfo_x86 *c) · line 1062

Quoted 5 lines
arch/x86/kernel/cpu/amd.c +2 -0
@@ -1058,6 +1058,8 @@ static void init_amd(struct cpuinfo_x86 *c)
 
  	/* AMD CPUs don't need fencing after x2APIC/TSC_DEADLINE MSR writes. */
  	clear_cpu_cap(c, X86_FEATURE_APIC_MSRS_FENCE);
+
+	bus_lock_init();

Can this call and the one in the intel.c be moved to common.c?

Thanks,
Tom

Quoted 3 lines
arch/x86/kernel/cpu/amd.c +0 -0
  }
 
  #ifdef CONFIG_X86_32
#6 lore raw

Re: [PATCH 2/3] x86/bus_lock: Add support for AMD

Quoted 11 lines

arch/x86/kernel/cpu/amd.c static void init_amd(struct cpuinfo_x86 *c) · line 1061

Quoted 9 lines
arch/x86/kernel/cpu/amd.c +2 -0
index 39f316d50ae4..013d16479a24 100644
@@ -1058,6 +1058,8 @@ static void init_amd(struct cpuinfo_x86 *c)
         /* AMD CPUs don't need fencing after x2APIC/TSC_DEADLINE MSR writes. */
       clear_cpu_cap(c, X86_FEATURE_APIC_MSRS_FENCE);
+
+    bus_lock_init();

Can this call and the one in the intel.c be moved to common.c?

Makes sense. Will do it.

Thanks,
Ravi

#7 lore raw

Re: [PATCH 2/3] x86/bus_lock: Add support for AMD

In reply to Ravi Bangoria
Quoted 11 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Add support for the same in Linux. Bus Lock Detect is enumerated with cpuid CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653

Is there any chance of getting something similar to Intel's "VMM bus-lock detection," which causes a trap-style VM-exit on a bus lock event?

#8 lore raw

Re: [PATCH 2/3] x86/bus_lock: Add support for AMD

Quoted 9 lines · Jim Mattson
Quoted 8 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Add support for the same in Linux. Bus Lock Detect is enumerated with cpuid CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

Quoted 7 lines
Quoted 3 lines

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653

Is there any chance of getting something similar to Intel's "VMM bus-lock detection," which causes a trap-style VM-exit on a bus lock event?

You are probably asking about "Bus Lock Threshold". Please see "15.14.5 Bus Lock Threshold" in the same doc. fwiw, Bus Lock Threshold is of fault style.

Thanks,
Ravi

#9 lore raw

PATCH 3/3 KVM SVM: Add Bus Lock Detect support

In reply to Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect. Add support for it in KVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the KVM.

---
 arch/x86/kvm/svm/nested.c |  3 ++-
 arch/x86/kvm/svm/svm.c    | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 2 deletions(-)
arch/x86/kvm/svm/nested.c +2 -1
index 55b9a6d96bcf..6e93c2d9e7df 100644
@@ -586,7 +586,8 @@ static void nested_vmcb02_prepare_save(struct vcpu_svm *svm, struct vmcb *vmcb12
 	/* These bits will be set properly on the first execution when new_vmc12 is true */
 	if (unlikely(new_vmcb12 || vmcb_is_dirty(vmcb12, VMCB_DR))) {
 		vmcb02->save.dr7 = svm->nested.save.dr7 | DR7_FIXED_1;
-		svm->vcpu.arch.dr6  = svm->nested.save.dr6 | DR6_ACTIVE_LOW;
+		/* DR6_RTM is not supported on AMD as of now. */
+		svm->vcpu.arch.dr6  = svm->nested.save.dr6 | DR6_FIXED_1 | DR6_RTM;
 		vmcb_mark_dirty(vmcb02, VMCB_DR);
 	}
 
arch/x86/kvm/svm/svm.c +15 -1
index d1a9f9951635..60f3af9bdacb 100644
@@ -1038,7 +1038,8 @@ void svm_update_lbrv(struct kvm_vcpu *vcpu)
 {
 	struct vcpu_svm *svm = to_svm(vcpu);
 	bool current_enable_lbrv = svm->vmcb->control.virt_ext & LBR_CTL_ENABLE_MASK;
-	bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & DEBUGCTLMSR_LBR) ||
+	u64 dbgctl_buslock_lbr = DEBUGCTLMSR_BUS_LOCK_DETECT | DEBUGCTLMSR_LBR;
+	bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & dbgctl_buslock_lbr) ||
 			    (is_guest_mode(vcpu) && guest_can_use(vcpu, X86_FEATURE_LBRV) &&
 			    (svm->nested.ctl.virt_ext & LBR_CTL_ENABLE_MASK));
 
@@ -3119,6 +3120,10 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr)
 		if (data & DEBUGCTL_RESERVED_BITS)
 			return 1;
 
+		if ((data & DEBUGCTLMSR_BUS_LOCK_DETECT) &&
+		    !guest_cpuid_has(vcpu, X86_FEATURE_BUS_LOCK_DETECT))
+			return 1;
+
 		svm_get_lbr_vmcb(svm)->save.dbgctl = data;
 		svm_update_lbrv(vcpu);
 		break;
@@ -5157,6 +5162,15 @@ static __init void svm_set_cpu_caps(void)
 
 	/* CPUID 0x8000001F (SME/SEV features) */
 	sev_set_cpu_caps();
+
+	/*
+	 * LBR Virtualization must be enabled to support BusLockTrap inside the
+	 * guest, since BusLockTrap is enabled through MSR_IA32_DEBUGCTLMSR and
+	 * MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is
+	 * enabled.
+	 */
+	if (!lbrv)
+		kvm_cpu_cap_clear(X86_FEATURE_BUS_LOCK_DETECT);
 }
 
 static __init int svm_hardware_setup(void)
Signature · 1 line
2.44.0
#10 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 4 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect. Add support for it in KVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the KVM.

This is woefully incomplete, e.g. db_interception() needs to be updated to decipher whether the #DB is the responsbility of the host or of the guest.

Honestly, I don't see any point in virtualizing this in KVM. As Jim alluded to, what's far, far more interesting for KVM is "Bus Lock Threshold". Virtualizing this for the guest would have been nice to have during the initial split-lock #AC support, but now I'm skeptical the complexity is worth the payoff.

I suppose we could allow it if #DB isn't interecepted, at which point the enabling required is minimal?

Quoted 64 lines
---
 arch/x86/kvm/svm/nested.c |  3 ++-
 arch/x86/kvm/svm/svm.c    | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 2 deletions(-)
arch/x86/kvm/svm/nested.c +2 -1
index 55b9a6d96bcf..6e93c2d9e7df 100644
@@ -586,7 +586,8 @@ static void nested_vmcb02_prepare_save(struct vcpu_svm *svm, struct vmcb *vmcb12
 	/* These bits will be set properly on the first execution when new_vmc12 is true */
 	if (unlikely(new_vmcb12 || vmcb_is_dirty(vmcb12, VMCB_DR))) {
 		vmcb02->save.dr7 = svm->nested.save.dr7 | DR7_FIXED_1;
-		svm->vcpu.arch.dr6  = svm->nested.save.dr6 | DR6_ACTIVE_LOW;
+		/* DR6_RTM is not supported on AMD as of now. */
+		svm->vcpu.arch.dr6  = svm->nested.save.dr6 | DR6_FIXED_1 | DR6_RTM;
 		vmcb_mark_dirty(vmcb02, VMCB_DR);
 	}
 
arch/x86/kvm/svm/svm.c +15 -1
index d1a9f9951635..60f3af9bdacb 100644
@@ -1038,7 +1038,8 @@ void svm_update_lbrv(struct kvm_vcpu *vcpu)
 {
 	struct vcpu_svm *svm = to_svm(vcpu);
 	bool current_enable_lbrv = svm->vmcb->control.virt_ext & LBR_CTL_ENABLE_MASK;
-	bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & DEBUGCTLMSR_LBR) ||
+	u64 dbgctl_buslock_lbr = DEBUGCTLMSR_BUS_LOCK_DETECT | DEBUGCTLMSR_LBR;
+	bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & dbgctl_buslock_lbr) ||
 			    (is_guest_mode(vcpu) && guest_can_use(vcpu, X86_FEATURE_LBRV) &&
 			    (svm->nested.ctl.virt_ext & LBR_CTL_ENABLE_MASK));
 
@@ -3119,6 +3120,10 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr)
 		if (data & DEBUGCTL_RESERVED_BITS)
 			return 1;
 
+		if ((data & DEBUGCTLMSR_BUS_LOCK_DETECT) &&
+		    !guest_cpuid_has(vcpu, X86_FEATURE_BUS_LOCK_DETECT))
+			return 1;
+
 		svm_get_lbr_vmcb(svm)->save.dbgctl = data;
 		svm_update_lbrv(vcpu);
 		break;
@@ -5157,6 +5162,15 @@ static __init void svm_set_cpu_caps(void)
 
 	/* CPUID 0x8000001F (SME/SEV features) */
 	sev_set_cpu_caps();
+
+	/*
+	 * LBR Virtualization must be enabled to support BusLockTrap inside the
+	 * guest, since BusLockTrap is enabled through MSR_IA32_DEBUGCTLMSR and
+	 * MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is
+	 * enabled.
+	 */
+	if (!lbrv)
+		kvm_cpu_cap_clear(X86_FEATURE_BUS_LOCK_DETECT);
 }
 
 static __init int svm_hardware_setup(void)
Signature · 1 line
2.44.0
#11 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Hi Sean,

Quoted 8 lines · Sean Christopherson
Quoted 4 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect. Add support for it in KVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the KVM.

This is woefully incomplete, e.g. db_interception() needs to be updated to decipher whether the #DB is the responsbility of the host or of the guest.

Can you please elaborate. Are you referring to vcpu->guest_debug thingy?

Quoted 4 lines

Honestly, I don't see any point in virtualizing this in KVM. As Jim alluded to, what's far, far more interesting for KVM is "Bus Lock Threshold". Virtualizing this for the guest would have been nice to have during the initial split-lock #AC support, but now I'm skeptical the complexity is worth the payoff.

This has a valid usecase of penalizing offending processes. I'm not sure how much it's really used in the production though.

Quoted 2 lines

I suppose we could allow it if #DB isn't interecepted, at which point the enabling required is minimal?

The feature uses DEBUG_CTL MSR, #DB and DR6 register. Do you mean expose it when all three are accelerated or just #DB?

Thanks for the feedback,
Ravi

#12 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 9 lines · Ravi Bangoria

Hi Sean,

Quoted 6 lines · Sean Christopherson
Quoted 4 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect. Add support for it in KVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the KVM.

Quoted 4 lines
Quoted 2 lines

This is woefully incomplete, e.g. db_interception() needs to be updated to decipher whether the #DB is the responsbility of the host or of the guest.

Can you please elaborate. Are you referring to vcpu->guest_debug thingy?

Yes. More broadly, all of db_interception().

Quoted 7 lines
Quoted 4 lines

Honestly, I don't see any point in virtualizing this in KVM. As Jim alluded to, what's far, far more interesting for KVM is "Bus Lock Threshold". Virtualizing this for the guest would have been nice to have during the initial split-lock #AC support, but now I'm skeptical the complexity is worth the payoff.

This has a valid usecase of penalizing offending processes. I'm not sure how much it's really used in the production though.

Yeah, but split-lock #AC and #DB have existed on Intel for years, and no one has put in the effort to land KVM support, despite the series getting as far as v9[*]. Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

Anyways, my point is that, except for SEV-ES+ where there's no good reason NOT to virtualize Bus Lock Detect, I'm not convinced that it's worth virtualizing bus-lock #DBs.

[*] https://lore.kernel.org/all/[email protected]

Quoted 5 lines
Quoted 2 lines

I suppose we could allow it if #DB isn't interecepted, at which point the enabling required is minimal?

The feature uses DEBUG_CTL MSR, #DB and DR6 register. Do you mean expose it when all three are accelerated or just #DB?

I mean that if KVM isn't intercepting #DB, then there's no extra complexity needed to sort out whether the #DB "belongs" to the host or the guest. See commit 90cbf6d914ad ("KVM: SEV-ES: Eliminate #DB intercept when DebugSwap enabled").

#13 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 22 lines · Sean Christopherson
Quoted 9 lines · Ravi Bangoria

Hi Sean,

Quoted 6 lines · Sean Christopherson
Quoted 4 lines · Ravi Bangoria

Upcoming AMD uarch will support Bus Lock Detect. Add support for it in KVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the KVM.

Quoted 4 lines
Quoted 2 lines

This is woefully incomplete, e.g. db_interception() needs to be updated to decipher whether the #DB is the responsbility of the host or of the guest.

Can you please elaborate. Are you referring to vcpu->guest_debug thingy?

Yes. More broadly, all of db_interception().

Quoted 5 lines
Quoted 4 lines

Honestly, I don't see any point in virtualizing this in KVM. As Jim alluded to, what's far, far more interesting for KVM is "Bus Lock Threshold". Virtualizing this for the guest would have been nice to have during the initial split-lock #AC support, but now I'm skeptical the complexity is worth the payoff.

Quoted 5 lines
Quoted 2 lines

This has a valid usecase of penalizing offending processes. I'm not sure how much it's really used in the production though.

Yeah, but split-lock #AC and #DB have existed on Intel for years, and no one has put in the effort to land KVM support, despite the series getting as far as v9[*].

Split-Lock Detect through #AC and Bus Lock Detect through #DB are independent features. AMD supports only Bus Lock Detect with #DB. I'm not sure about Split Lock Detect but Intel supports Bus Lock Detect in the guest. These are the relevant commits:

https://git.kernel.org/torvalds/c/9a3ecd5e2aa10
https://git.kernel.org/torvalds/c/e8ea85fb280ec
https://git.kernel.org/torvalds/c/76ea438b4afcd

Quoted 3 lines

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

Please correct me if I misunderstood your comment.

Quoted 15 lines

Anyways, my point is that, except for SEV-ES+ where there's no good reason NOT to virtualize Bus Lock Detect, I'm not convinced that it's worth virtualizing bus-lock #DBs.

[*] https://lore.kernel.org/all/[email protected]

Quoted 5 lines
Quoted 2 lines

I suppose we could allow it if #DB isn't interecepted, at which point the enabling required is minimal?

The feature uses DEBUG_CTL MSR, #DB and DR6 register. Do you mean expose it when all three are accelerated or just #DB?

I mean that if KVM isn't intercepting #DB, then there's no extra complexity needed to sort out whether the #DB "belongs" to the host or the guest. See commit 90cbf6d914ad ("KVM: SEV-ES: Eliminate #DB intercept when DebugSwap enabled").

#14 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 10 lines · Ravi Bangoria
Quoted 3 lines · Sean Christopherson

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

I'm talking about the case where the host wants to do something in response to bus locks that occurred in the guest. E.g. if the host is taking punitive action, say by stalling the vCPU, then the guest kernel could bypass that behavior by enabling bus lock detect itself.

Maybe it's moot point in practice, since it sounds like Bus Lock Threshold will be available at the same time.

Ugh, and if we wanted to let the host handle guest-induced #DBs, we'd need code to keep Bus Lock Detect enabled in the guest since it resides in DEBUG_CTL. Bah.

So I guess if the vcpu->guest_debug part is fairly straightforward, it probably makes to virtualize Bus Lock Detect because the only reason not to virtualize it would actually require more work/code in KVM.

I'd still love to see Bus Lock Threshold support sooner than later though :-)

#15 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Sean,

Apologies for the delay. I was waiting for Bus Lock Threshold patches to be posted upstream:

https://lore.kernel.org/r/[email protected]

Quoted 20 lines · Sean Christopherson
Quoted 10 lines · Ravi Bangoria
Quoted 3 lines · Sean Christopherson

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

I'm talking about the case where the host wants to do something in response to bus locks that occurred in the guest. E.g. if the host is taking punitive action, say by stalling the vCPU, then the guest kernel could bypass that behavior by enabling bus lock detect itself.

Maybe it's moot point in practice, since it sounds like Bus Lock Threshold will be available at the same time.

Quoted 6 lines

Ugh, and if we wanted to let the host handle guest-induced #DBs, we'd need code to keep Bus Lock Detect enabled in the guest since it resides in DEBUG_CTL. Bah.

So I guess if the vcpu->guest_debug part is fairly straightforward, it probably makes to virtualize Bus Lock Detect because the only reason not to virtualize it would actually require more work/code in KVM.

KVM forwards #DB to Qemu when vcpu->guest_debug is set and it's Qemu's responsibility to re-inject exception when Bus Lock Trap is enabled inside the guest. I realized that it is broken so I've prepared a Qemu patch, embedding it at the end.

Quoted 1 line

I'd still love to see Bus Lock Threshold support sooner than later though :-)

With Bus Lock Threshold enabled, I assume the changes introduced by this patch plus Qemu fix are sufficient to support Bus Lock Trap inside the guest?

Thanks,
Ravi

---><---
From 0b01859f99c4c5e18323e3f4ac19d1f3e5ad4aee Mon Sep 17 00:00:00 2001
From: Ravi Bangoria <[email protected]>
Date: Thu, 4 Jul 2024 06:48:24 +0000
Subject: [PATCH] target/i386: Add Bus Lock Detect support

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Bus Lock Detect is enumerated with cpuid Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

Qemu supports remote debugging through host gdb (the "gdbstub" facility) where some of the remote debugging features like instruction and data breakpoints relies on the same hardware infrastructure (#DB, DR6 etc.) that Bus Lock Detect also uses. Instead of handling internally, KVM forwards #DB to Qemu when remote debugging is ON and #DB is being intercepted. It's Qemu's responsibility to re-inject the exception to guest when some of the exception source bits (in DR6) are not being handled by Qemu remote debug handler. Bus Lock Detect is one such case.

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653
---
 target/i386/cpu.h     | 1 +
 target/i386/kvm/kvm.c | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)
target/i386/cpu.h +1 -0
index c64ef0c1a2..89bcff2fa3 100644
@@ -271,6 +271,7 @@ typedef enum X86Seg {
                 | CR4_SMEP_MASK | CR4_SMAP_MASK | CR4_PKE_MASK | CR4_PKS_MASK \
                 | CR4_LAM_SUP_MASK))
 
+#define DR6_BLD         (1 << 11)
 #define DR6_BD          (1 << 13)
 #define DR6_BS          (1 << 14)
 #define DR6_BT          (1 << 15)
target/i386/kvm/kvm.c +2 -2
index 6c864e4611..d128d4e5ca 100644
@@ -5141,14 +5141,14 @@ static int kvm_handle_debug(X86CPU *cpu,
     } else if (kvm_find_sw_breakpoint(cs, arch_info->pc)) {
         ret = EXCP_DEBUG;
     }
-    if (ret == 0) {
+    if (ret == 0 || !(arch_info->dr6 & DR6_BLD)) {
         cpu_synchronize_state(cs);
         assert(env->exception_nr == -1);
 
         /* pass to guest */
         kvm_queue_exception(env, arch_info->exception,
                             arch_info->exception == EXCP01_DB,
-                            arch_info->dr6);
+                            ret == 0 ? arch_info->dr6 ^ DR6_BLD : DR6_BLD);
         env->has_error_code = 0;
     }
 
Signature · 1 line
2.34.1
#16 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 41 lines · Ravi Bangoria

Sean,

Apologies for the delay. I was waiting for Bus Lock Threshold patches to be posted upstream:

https://lore.kernel.org/r/[email protected]

Quoted 20 lines · Sean Christopherson
Quoted 10 lines · Ravi Bangoria
Quoted 3 lines · Sean Christopherson

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

I'm talking about the case where the host wants to do something in response to bus locks that occurred in the guest. E.g. if the host is taking punitive action, say by stalling the vCPU, then the guest kernel could bypass that behavior by enabling bus lock detect itself.

Maybe it's moot point in practice, since it sounds like Bus Lock Threshold will be available at the same time.

Quoted 6 lines

Ugh, and if we wanted to let the host handle guest-induced #DBs, we'd need code to keep Bus Lock Detect enabled in the guest since it resides in DEBUG_CTL. Bah.

So I guess if the vcpu->guest_debug part is fairly straightforward, it probably makes to virtualize Bus Lock Detect because the only reason not to virtualize it would actually require more work/code in KVM.

KVM forwards #DB to Qemu when vcpu->guest_debug is set and it's Qemu's responsibility to re-inject exception when Bus Lock Trap is enabled inside the guest. I realized that it is broken so I've prepared a Qemu patch, embedding it at the end.

Quoted 5 lines
Quoted 1 line

I'd still love to see Bus Lock Threshold support sooner than later though :-)

With Bus Lock Threshold enabled, I assume the changes introduced by this patch plus Qemu fix are sufficient to support Bus Lock Trap inside the guest?

In any case, it seems that commit 76ea438b4afc ("KVM: X86: Expose bus lock debug exception to guest") prematurely advertised the presence of X86_FEATURE_BUS_LOCK to userspace on non-Intel platforms. We should probably either accept these changes or fix up that commit. Either way, something should be done for all active branches back to v5.15.

Quoted 71 lines

Thanks,
Ravi

---><---
From 0b01859f99c4c5e18323e3f4ac19d1f3e5ad4aee Mon Sep 17 00:00:00 2001
From: Ravi Bangoria <[email protected]>
Date: Thu, 4 Jul 2024 06:48:24 +0000
Subject: [PATCH] target/i386: Add Bus Lock Detect support

Upcoming AMD uarch will support Bus Lock Detect (called Bus Lock Trap in AMD docs). Bus Lock Detect is enumerated with cpuid Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1].

Qemu supports remote debugging through host gdb (the "gdbstub" facility) where some of the remote debugging features like instruction and data breakpoints relies on the same hardware infrastructure (#DB, DR6 etc.) that Bus Lock Detect also uses. Instead of handling internally, KVM forwards #DB to Qemu when remote debugging is ON and #DB is being intercepted. It's Qemu's responsibility to re-inject the exception to guest when some of the exception source bits (in DR6) are not being handled by Qemu remote debug handler. Bus Lock Detect is one such case.

[1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June

     2023, Vol 2, 13.1.3.6 Bus Lock Trap
     https://bugzilla.kernel.org/attachment.cgi?id=304653
---
 target/i386/cpu.h     | 1 +
 target/i386/kvm/kvm.c | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)
target/i386/cpu.h +1 -0
index c64ef0c1a2..89bcff2fa3 100644
@@ -271,6 +271,7 @@ typedef enum X86Seg {
                 | CR4_SMEP_MASK | CR4_SMAP_MASK | CR4_PKE_MASK | CR4_PKS_MASK \
                 | CR4_LAM_SUP_MASK))
 
+#define DR6_BLD         (1 << 11)
 #define DR6_BD          (1 << 13)
 #define DR6_BS          (1 << 14)
 #define DR6_BT          (1 << 15)
target/i386/kvm/kvm.c +2 -3
index 6c864e4611..d128d4e5ca 100644
@@ -5141,14 +5141,14 @@ static int kvm_handle_debug(X86CPU *cpu,
     } else if (kvm_find_sw_breakpoint(cs, arch_info->pc)) {
         ret = EXCP_DEBUG;
     }
-    if (ret == 0) {
+    if (ret == 0 || !(arch_info->dr6 & DR6_BLD)) {
         cpu_synchronize_state(cs);
         assert(env->exception_nr == -1);
 
         /* pass to guest */
         kvm_queue_exception(env, arch_info->exception,
                             arch_info->exception == EXCP01_DB,
-                            arch_info->dr6);
+                            ret == 0 ? arch_info->dr6 ^ DR6_BLD : DR6_BLD);
         env->has_error_code = 0;
     }
 
--

2.34.1

#17 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 48 lines · Jim Mattson
Quoted 41 lines · Ravi Bangoria

Sean,

Apologies for the delay. I was waiting for Bus Lock Threshold patches to be posted upstream:

https://lore.kernel.org/r/[email protected]

Quoted 20 lines · Sean Christopherson
Quoted 10 lines · Ravi Bangoria
Quoted 3 lines · Sean Christopherson

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

I'm talking about the case where the host wants to do something in response to bus locks that occurred in the guest. E.g. if the host is taking punitive action, say by stalling the vCPU, then the guest kernel could bypass that behavior by enabling bus lock detect itself.

Maybe it's moot point in practice, since it sounds like Bus Lock Threshold will be available at the same time.

Quoted 6 lines

Ugh, and if we wanted to let the host handle guest-induced #DBs, we'd need code to keep Bus Lock Detect enabled in the guest since it resides in DEBUG_CTL. Bah.

So I guess if the vcpu->guest_debug part is fairly straightforward, it probably makes to virtualize Bus Lock Detect because the only reason not to virtualize it would actually require more work/code in KVM.

KVM forwards #DB to Qemu when vcpu->guest_debug is set and it's Qemu's responsibility to re-inject exception when Bus Lock Trap is enabled inside the guest. I realized that it is broken so I've prepared a Qemu patch, embedding it at the end.

Quoted 5 lines
Quoted 1 line

I'd still love to see Bus Lock Threshold support sooner than later though :-)

With Bus Lock Threshold enabled, I assume the changes introduced by this patch plus Qemu fix are sufficient to support Bus Lock Trap inside the guest?

Quoted 5 lines

In any case, it seems that commit 76ea438b4afc ("KVM: X86: Expose bus lock debug exception to guest") prematurely advertised the presence of X86_FEATURE_BUS_LOCK to userspace on non-Intel platforms. We should probably either accept these changes or fix up that commit. Either way, something should be done for all active branches back to v5.15.

Drat. Yeah, we need a patch to clear BUS_LOCK_DETECT in svm_set_cpu_caps(), marked for stable@. Then this series can remove that clearing.

At least I caught it for CET[*]! It'd be nice to not have to rely on humans to detect potential issues like this, but I can't think of a way to programmatically handle this situation without incurring an annoying amount of overhead and/or duplicate code between VMX and SVM.

[*] https://lore.kernel.org/all/[email protected]

#18 lore raw

Re: [PATCH 3/3] KVM SVM: Add Bus Lock Detect support

Quoted 58 lines · Sean Christopherson
Quoted 48 lines · Jim Mattson
Quoted 41 lines · Ravi Bangoria

Sean,

Apologies for the delay. I was waiting for Bus Lock Threshold patches to be posted upstream:

https://lore.kernel.org/r/[email protected]

Quoted 20 lines · Sean Christopherson
Quoted 10 lines · Ravi Bangoria
Quoted 3 lines · Sean Christopherson

Some of the problems on Intel were due to the awful FMS-based feature detection, but those weren't the only hiccups. E.g. IIRC, we never sorted out what should happen if both the host and guest want bus-lock #DBs.

I've to check about vcpu->guest_debug part, but keeping that aside, host and guest can use Bus Lock Detect in parallel because, DEBUG_CTL MSR and DR6 register are save/restored in VMCB, hardware cause a VMEXIT_EXCEPTION_1 for guest #DB(when intercepted) and hardware raises #DB on host when it's for the host.

I'm talking about the case where the host wants to do something in response to bus locks that occurred in the guest. E.g. if the host is taking punitive action, say by stalling the vCPU, then the guest kernel could bypass that behavior by enabling bus lock detect itself.

Maybe it's moot point in practice, since it sounds like Bus Lock Threshold will be available at the same time.

Quoted 6 lines

Ugh, and if we wanted to let the host handle guest-induced #DBs, we'd need code to keep Bus Lock Detect enabled in the guest since it resides in DEBUG_CTL. Bah.

So I guess if the vcpu->guest_debug part is fairly straightforward, it probably makes to virtualize Bus Lock Detect because the only reason not to virtualize it would actually require more work/code in KVM.

KVM forwards #DB to Qemu when vcpu->guest_debug is set and it's Qemu's responsibility to re-inject exception when Bus Lock Trap is enabled inside the guest. I realized that it is broken so I've prepared a Qemu patch, embedding it at the end.

Quoted 5 lines
Quoted 1 line

I'd still love to see Bus Lock Threshold support sooner than later though :-)

With Bus Lock Threshold enabled, I assume the changes introduced by this patch plus Qemu fix are sufficient to support Bus Lock Trap inside the guest?

Quoted 5 lines

In any case, it seems that commit 76ea438b4afc ("KVM: X86: Expose bus lock debug exception to guest") prematurely advertised the presence of X86_FEATURE_BUS_LOCK to userspace on non-Intel platforms. We should probably either accept these changes or fix up that commit. Either way, something should be done for all active branches back to v5.15.

Drat. Yeah, we need a patch to clear BUS_LOCK_DETECT in svm_set_cpu_caps(), marked for stable@. Then this series can remove that clearing.

Quoted 6 lines

At least I caught it for CET[*]! It'd be nice to not have to rely on humans to detect potential issues like this, but I can't think of a way to programmatically handle this situation without incurring an annoying amount of overhead and/or duplicate code between VMX and SVM.

[*] https://lore.kernel.org/all/[email protected]

Sure, I'll add a patch and respin the series.

Thanks,
Ravi