Skip to contentSkip to conversation

KVM: x86: Check hypercall's exit to userspace generically

PATCH Superseded Binbin Wu 5 participants 19 messages Aug 13, 2024 – Aug 19, 2024

Subsystems (3)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Binbin Wu

author
#0 lore raw

v2 cover KVM: x86: Check hypercall's exit to userspace generically

Currently in kvm_emulate_hypercall, KVM_HC_MAP_GPA_RANGE is checked specifically to decide whether a KVM hypercall needs to exit to userspace or not. Do the check based on the hypercall_exit_enabled field of struct kvm_arch.

Also use the API is_kvm_hc_exit_enabled() to replace the opencode.

---
v2:
- Check the return value of __kvm_emulate_hypercall() before checking hypercall_exit_enabled to avoid an invalid KVM hypercall nr.
https://lore.kernel.org/kvm/[email protected]/
- Add a warning if a hypercall nr out of the range of hypercall_exit_enabled can express.

Binbin Wu (2):
KVM: x86: Check hypercall's exit to userspace generically
KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

 arch/x86/kvm/svm/sev.c | 4 ++--
 arch/x86/kvm/x86.c     | 6 +++---
 arch/x86/kvm/x86.h     | 7 +++++++
 3 files changed, 12 insertions(+), 5 deletions(-)

base-commit: 332d2c1d713e232e163386c35a3ba0c1b90df83f

Signature · 1 line
2.43.2
author
#1 lore raw

PATCH v2 1/2 KVM: x86: Check hypercall's exit to userspace generically

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
 arch/x86/kvm/x86.c | 4 ++--
 arch/x86/kvm/x86.h | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
 	cpl = kvm_x86_call(get_cpl)(vcpu);
 
 	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
 		return 0;
 
 	if (!op_64_bit)
arch/x86/kvm/x86.h +7 -0
index 50596f6f8320..0cbec76b42e6 100644
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
 			 unsigned int port, void *data,  unsigned int count,
 			 int in);
 
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;
+
+	return kvm->arch.hypercall_exit_enabled & (1 << hc_nr);
+}
 #endif
Signature · 1 line
2.43.2
#2 lore raw
Quoted 33 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
 arch/x86/kvm/x86.c | 4 ++--
 arch/x86/kvm/x86.h | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
 	cpl = kvm_x86_call(get_cpl)(vcpu);
 
 	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
 		return 0;
 
 	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 552

Quoted 6 lines
arch/x86/kvm/x86.h +3 -0
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
 			 unsigned int port, void *data,  unsigned int count,
 			 int in);
 
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))

How about:

if (!(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK))

KVM_EXIT_HYPERCALL_VALID_MASK is used to guard kvm->arch.hypercall_exit_enabled on KVM_CAP_EXIT_HYPERCALL, "hc_nr > maximum supported hc" AND "hc_nr <= bit_count(kvm->arch.hypercall_exit_enabled)" should be treated as invalid yet to me.

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 555

Quoted 3 lines
arch/x86/kvm/x86.h +3 -0
+		return false;
+
+	return kvm->arch.hypercall_exit_enabled & (1 << hc_nr);

BIT(xx) instead of "1 << hc_nr" for better readability.

Quoted 6 lines
arch/x86/kvm/x86.h +1 -1
+}
 #endif
--

2.43.2

#3 lore raw
Quoted 43 lines · Yuan Yao
Quoted 33 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
 arch/x86/kvm/x86.c | 4 ++--
 arch/x86/kvm/x86.h | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
 	cpl = kvm_x86_call(get_cpl)(vcpu);
 
 	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
 		return 0;
 
 	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 552

Quoted 6 lines
arch/x86/kvm/x86.h +3 -0
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
 			 unsigned int port, void *data,  unsigned int count,
 			 int in);
 
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))

How about:

Quoted 6 lines

if (!(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK))

KVM_EXIT_HYPERCALL_VALID_MASK is used to guard kvm->arch.hypercall_exit_enabled on KVM_CAP_EXIT_HYPERCALL, "hc_nr > maximum supported hc" AND "hc_nr <= bit_count(kvm->arch.hypercall_exit_enabled)" should be treated as invalid yet to me.

Not real good idea. Rely on hypercall_exit_enabled is good enough, this brings unnecessary complexity.

Quoted 14 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 555

Quoted 4 lines
arch/x86/kvm/x86.h +3 -0
+		return false;
+
+	return kvm->arch.hypercall_exit_enabled & (1 << hc_nr);

BIT(xx) instead of "1 << hc_nr" for better readability.

Quoted 6 lines
arch/x86/kvm/x86.h +1 -1
+}
 #endif
--

2.43.2

#4 lore raw
In reply to Binbin Wu
Quoted 33 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
 arch/x86/kvm/x86.c | 4 ++--
 arch/x86/kvm/x86.h | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
 	cpl = kvm_x86_call(get_cpl)(vcpu);
 
 	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
 		return 0;
 
 	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 7 lines
arch/x86/kvm/x86.h +4 -0
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
 			 unsigned int port, void *data,  unsigned int count,
 			 int in);
 
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

             !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

Signature · 1 line
Isaku Yamahata <[email protected]>
#5 lore raw
Quoted 46 lines · Isaku Yamahata
Quoted 33 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++
  2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
  	cpl = kvm_x86_call(get_cpl)(vcpu);
 
  	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
  		return 0;
 
  	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 7 lines
arch/x86/kvm/x86.h +4 -0
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
  			 unsigned int port, void *data,  unsigned int count,
  			 int in);
 
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

Quoted 2 lines
              !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

On the other hand, albeit WARN_ON_ONCE() is runtime check, but it is always there.

In fact, the @hc_nr (or @nr) in the kvm_emulate_hypercall() is read from the RAX register:

        nr = kvm_rax_read(vcpu);

So I don't see how the compiler can be smart enough to determine the value at compile time.

In fact, I tried to build by removing the __builtin_constant_p() but got below error (sorry for text wrap but you can see the error I believe).

root@server:/home/kai/tdx/linux# make M=arch/x86/kvm/ W=1
  CC [M]  arch/x86/kvm/x86.o
In file included from <command-line>:
In function ‘is_kvm_hc_exit_enabled’,
    inlined from ‘kvm_emulate_hypercall’ at arch/x86/kvm/x86.c:10254:14:
././include/linux/compiler_types.h:510:45: error: call to ‘__compiletime_assert_3873’ declared with attribute error: BUILD_BUG_ON failed: !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK)
  510 |         _compiletime_assert(condition, msg, 
__compiletime_assert_, __COUNTER__)
      |                                             ^
#6 lore raw
Quoted 49 lines · Kai
Quoted 43 lines · Isaku Yamahata
Quoted 31 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++
  2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
  	cpl = kvm_x86_call(get_cpl)(vcpu);
  	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
  		return 0;
  	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 552

Quoted 6 lines
arch/x86/kvm/x86.h +4 -0
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
  			 unsigned int port, void *data,  unsigned int count,
  			 int in);
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

Quoted 2 lines
              !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

Quoted 6 lines

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

It depends on what we'd like to detect. BUILT_BUG_ON(__builtin_constant_p()) can detect the usage in the patch 2/2, is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE). The potential future use of is_kvm_hc_exit_enabled(, KVM_HC_MAP_future_hypercall).

Although this version doesn't help for the one in kvm_emulate_hypercall(), !ret check is done first to avoid WARN_ON_ONCE() to hit here.

Maybe we can just drop this WARN_ON_ONCE().

Signature · 1 line
Isaku Yamahata <[email protected]>
author
#7 lore raw
Quoted 41 lines · Isaku Yamahata
Quoted 38 lines · Kai
Quoted 36 lines · Isaku Yamahata
Quoted 33 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
   arch/x86/kvm/x86.c | 4 ++--
   arch/x86/kvm/x86.h | 7 +++++++
   2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
   	cpl = kvm_x86_call(get_cpl)(vcpu);
   	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
   		return 0;
   	if (!op_64_bit)
arch/x86/kvm/x86.h +0 -0
index 50596f6f8320..0cbec76b42e6 100644
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
   			 unsigned int port, void *data,  unsigned int count,
   			 int in);
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 4 lines
arch/x86/kvm/x86.h +4 -0
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

               !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

My intention was to catch issue when KVM_HC_* grows and exceeds 32. I was looking a compile time check, but didn't find a proper one.

Quoted 6 lines
Quoted 6 lines

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

Quoted 7 lines

It depends on what we'd like to detect. BUILT_BUG_ON(__builtin_constant_p()) can detect the usage in the patch 2/2, is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE). The potential future use of is_kvm_hc_exit_enabled(, KVM_HC_MAP_future_hypercall).

Although this version doesn't help for the one in kvm_emulate_hypercall(), !ret check is done first to avoid WARN_ON_ONCE() to hit here.

Even !ret is checked first, it's still possible to hit the warning if KVM_HC_furture_hypercall >=32.

Quoted 2 lines

Maybe we can just drop this WARN_ON_ONCE().

Agree that a warning may not be a good option. What I wanted to guarantee was that "KVM_HC_* < 32" when hypercall_exit_enabled is u32.

#8 lore raw
In reply to Isaku Yamahata
Quoted 35 lines · Isaku Yamahata
Quoted 32 lines · Kai Huang
Quoted 29 lines · Isaku Yamahata
Quoted 26 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++
  2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
  	cpl = kvm_x86_call(get_cpl)(vcpu);
  	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
  		return 0;
  	if (!op_64_bit)
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 549

Quoted 8 lines
arch/x86/kvm/x86.h +1 -0
index 50596f6f8320..0cbec76b42e6 100644
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
  			 unsigned int port, void *data,  unsigned int count,
  			 int in);
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)

I would rather have "hypercall" in the name, "hc" never jumps out to me as being "hypercall". Maybe is_hypercall_exit_enabled(), user_exit_on_hypercall(), or just exit_on_hypercall()?

I'd probably vote for user_exit_on_hypercall(), as that clarifies it's all about exiting to userspace, not from the guest.

Quoted 11 lines
Quoted 11 lines
Quoted 8 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 3 lines
arch/x86/kvm/x86.h +3 -0
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

              !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

KVM does use __builtin_constant_p() to effectively disable some assertions when it's allowed (by KVM's arbitrary rules) to pass in a non-constant value. E.g. see all the vmcs_checkNN() helpers. If we didn't waive the assertion for values that aren't constant at compile-time, all of the segmentation code would need to be unwound into switch statements.

But for things like guest_cpuid_has(), the rule is that the input must be a compile-time constant.

Quoted 9 lines
Quoted 3 lines

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

It depends on what we'd like to detect. BUILT_BUG_ON(__builtin_constant_p()) can detect the usage in the patch 2/2, is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE). The potential future use of is_kvm_hc_exit_enabled(, KVM_HC_MAP_future_hypercall).

Quoted 4 lines

Although this version doesn't help for the one in kvm_emulate_hypercall(), !ret check is done first to avoid WARN_ON_ONCE() to hit here.

Maybe we can just drop this WARN_ON_ONCE().

Yeah, I think it makes sense to drop the WARN, otherwise I suspect we'll end up dancing around the helper just to avoid the warning.

I'm 50/50 on the BUILD_BUG_ON(). One one hand, it's kinda overkill. On the other hand, it's zero generated code.

#9 lore raw
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 9 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 4 lines
arch/x86/kvm/x86.h +3 -0
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

               !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

Quoted 8 lines
Quoted 2 lines
Quoted 2 lines

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

KVM does use __builtin_constant_p() to effectively disable some assertions when it's allowed (by KVM's arbitrary rules) to pass in a non-constant value. E.g. see all the vmcs_checkNN() helpers. If we didn't waive the assertion for values that aren't constant at compile-time, all of the segmentation code would need to be unwound into switch statements.

Yeah I saw vmcs_checkNN(), but I think __builtin_constant_p() makes sense for vmcs_checkNN()s because they are widely called. But is_kvm_hc_exit_enabled() doesn't seem so. But no hard opinion here. As you said, it's kinda overkill (or abused to use) but zero-generated code.

Quoted 13 lines

But for things like guest_cpuid_has(), the rule is that the input must be a compile-time constant.

Quoted 9 lines
Quoted 3 lines

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

It depends on what we'd like to detect. BUILT_BUG_ON(__builtin_constant_p()) can detect the usage in the patch 2/2, is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE). The potential future use of is_kvm_hc_exit_enabled(, KVM_HC_MAP_future_hypercall).

Quoted 7 lines
Quoted 4 lines

Although this version doesn't help for the one in kvm_emulate_hypercall(), !ret check is done first to avoid WARN_ON_ONCE() to hit here.

Maybe we can just drop this WARN_ON_ONCE().

Yeah, I think it makes sense to drop the WARN, otherwise I suspect we'll end up dancing around the helper just to avoid the warning.

Agreed, given @nr is from guest.

author
#10 lore raw
In reply to Sean Christopherson
Quoted 47 lines · Sean Christopherson
Quoted 34 lines · Isaku Yamahata
Quoted 31 lines · Kai Huang
Quoted 29 lines · Isaku Yamahata
Quoted 26 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

---
   arch/x86/kvm/x86.c | 4 ++--
   arch/x86/kvm/x86.h | 7 +++++++
   2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
   	cpl = kvm_x86_call(get_cpl)(vcpu);
   	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
   		return 0;
   	if (!op_64_bit)
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 549

Quoted 8 lines
arch/x86/kvm/x86.h +1 -0
index 50596f6f8320..0cbec76b42e6 100644
@@ -547,4 +547,11 @@ int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size,
   			 unsigned int port, void *data,  unsigned int count,
   			 int in);
+static inline bool is_kvm_hc_exit_enabled(struct kvm *kvm, unsigned long hc_nr)

I would rather have "hypercall" in the name, "hc" never jumps out to me as being "hypercall". Maybe is_hypercall_exit_enabled(), user_exit_on_hypercall(), or just exit_on_hypercall()?

Quoted 2 lines

I'd probably vote for user_exit_on_hypercall(), as that clarifies it's all about exiting to userspace, not from the guest.

user_exit_on_hypercall() looks good to me.
Thanks!

Quoted 30 lines
Quoted 10 lines
Quoted 10 lines
Quoted 8 lines

arch/x86/kvm/x86.h int kvm_sev_es_string_io(struct kvm_vcpu *vcpu, unsigned int size, · line 553

Quoted 4 lines
arch/x86/kvm/x86.h +3 -0
+{
+	if(WARN_ON_ONCE(hc_nr >= sizeof(kvm->arch.hypercall_exit_enabled) * 8))
+		return false;

Is this to detect potential bug? Maybe
BUILD_BUG_ON(__builtin_constant_p(hc_nr) &&

               !(BIT(hc_nr) & KVM_EXIT_HYPERCALL_VALID_MASK));

Overkill?

I don't think this is the correct way to use __builtin_constant_p(), i.e. it doesn't make sense to use __builtin_constant_p() in BUILD_BUG_ON().

KVM does use __builtin_constant_p() to effectively disable some assertions when it's allowed (by KVM's arbitrary rules) to pass in a non-constant value. E.g. see all the vmcs_checkNN() helpers. If we didn't waive the assertion for values that aren't constant at compile-time, all of the segmentation code would need to be unwound into switch statements.

But for things like guest_cpuid_has(), the rule is that the input must be a compile-time constant.

Quoted 11 lines
Quoted 3 lines

IIUC you need some build time guarantee here, but __builtin_constant_p() can return false, in which case the above BUILD_BUG_ON() does nothing, which defeats the purpose.

It depends on what we'd like to detect. BUILT_BUG_ON(__builtin_constant_p()) can detect the usage in the patch 2/2, is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE). The potential future use of is_kvm_hc_exit_enabled(, KVM_HC_MAP_future_hypercall).

Although this version doesn't help for the one in kvm_emulate_hypercall(), !ret check is done first to avoid WARN_ON_ONCE() to hit here.

Quoted 7 lines
Quoted 1 line

Maybe we can just drop this WARN_ON_ONCE().

Yeah, I think it makes sense to drop the WARN, otherwise I suspect we'll end up dancing around the helper just to avoid the warning.

I'm 50/50 on the BUILD_BUG_ON(). One one hand, it's kinda overkill. On the other hand, it's zero generated code.

Will remove the WARN_ON_ONCE().

Reviewed-by on v2 1/2
#11 lore raw
In reply to Binbin Wu
Quoted 8 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled. Make the check code generic based on it.

One nitpicking below:

Quoted 10 lines
---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++
  2 files changed, 9 insertions(+), 2 deletions(-)
arch/x86/kvm/x86.c +0 -0
index af6c8cf6a37a..6e16c9751af7 100644

arch/x86/kvm/x86.c int kvm_emulate_hypercall(struct kvm_vcpu *vcpu) · line 10231

Quoted 8 lines
arch/x86/kvm/x86.c +2 -2
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
  	cpl = kvm_x86_call(get_cpl)(vcpu);
 
  	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
  		return 0;

I believe you put "!ret" check first for a reason? Perhaps you can add a comment.

#12 lore raw
Quoted 5 lines · Kai
Quoted 5 lines
---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++
  2 files changed, 9 insertions(+), 2 deletions(-)
Quoted 15 lines

arch/x86/kvm/x86.c int kvm_emulate_hypercall(struct kvm_vcpu *vcpu) · line 10230

Quoted 12 lines
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
  	cpl = kvm_x86_call(get_cpl)(vcpu);
  	ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-	if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-		/* MAP_GPA tosses the request to the user space. */
+	if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+		/* The hypercall is requested to exit to userspace. */
  		return 0;

I believe you put "!ret" check first for a reason? Perhaps you can add a comment.

I think he'd like to avoid to hit WARN_ON_ONCE().

Signature · 1 line
Isaku Yamahata <[email protected]>
author
#13 lore raw
In reply to Huang, Kai
Quoted 21 lines · Kai
Quoted 8 lines · Binbin Wu

Check whether a KVM hypercall needs to exit to userspace or not based on hypercall_exit_enabled field of struct kvm_arch.

Userspace can request a hypercall to exit to userspace for handling by enable KVM_CAP_EXIT_HYPERCALL and the enabled hypercall will be set in hypercall_exit_enabled.  Make the check code generic based on it.

One nitpicking below:

Quoted 5 lines

---
  arch/x86/kvm/x86.c | 4 ++--
  arch/x86/kvm/x86.h | 7 +++++++

  2 files changed, 9 insertions(+), 2 deletions(-)
Quoted 16 lines

arch/x86/kvm/x86.c int kvm_emulate_hypercall(struct kvm_vcpu *vcpu) · line 10230

Quoted 12 lines
arch/x86/kvm/x86.c +2 -2
index af6c8cf6a37a..6e16c9751af7 100644
@@ -10226,8 +10226,8 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu)
       cpl = kvm_x86_call(get_cpl)(vcpu);
         ret = __kvm_emulate_hypercall(vcpu, nr, a0, a1, a2, a3, op_64_bit, cpl);
-    if (nr == KVM_HC_MAP_GPA_RANGE && !ret)
-        /* MAP_GPA tosses the request to the user space. */
+    if (!ret && is_kvm_hc_exit_enabled(vcpu->kvm, nr))
+        /* The hypercall is requested to exit to userspace. */
           return 0;

I believe you put "!ret" check first for a reason?  Perhaps you can add a comment.

Yes, check "!ret" first to make sure the input of is_kvm_hc_exit_enabled() is a valid KVM_HC_*. Will add a comment.
Thanks.

author
#14 lore raw

PATCH v2 2/2 KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

In reply to Binbin Wu

Use is_kvm_hc_exit_enabled() instead of opencode.

No functional change intended.

---
 arch/x86/kvm/svm/sev.c | 4 ++--
 arch/x86/kvm/x86.c     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
arch/x86/kvm/svm/sev.c +2 -2
index a16c873b3232..d622aab8351d 100644
@@ -3635,7 +3635,7 @@ static int snp_begin_psc_msr(struct vcpu_svm *svm, u64 ghcb_msr)
 		return 1; /* resume guest */
 	}
 
-	if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE))) {
+	if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE)) {
 		set_ghcb_msr(svm, GHCB_MSR_PSC_RESP_ERROR);
 		return 1; /* resume guest */
 	}
@@ -3718,7 +3718,7 @@ static int snp_begin_psc(struct vcpu_svm *svm, struct psc_buffer *psc)
 	bool huge;
 	u64 gfn;
 
-	if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE))) {
+	if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE)) {
 		snp_complete_psc(svm, VMGEXIT_PSC_ERROR_GENERIC);
 		return 1;
 	}
arch/x86/kvm/x86.c +1 -1
index 6e16c9751af7..9857c1984ef7 100644
@@ -10171,7 +10171,7 @@ unsigned long __kvm_emulate_hypercall(struct kvm_vcpu *vcpu, unsigned long nr,
 		u64 gpa = a0, npages = a1, attrs = a2;
 
 		ret = -KVM_ENOSYS;
-		if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE)))
+		if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE))
 			break;
 
 		if (!PAGE_ALIGNED(gpa) || !npages ||
Signature · 1 line
2.43.2
Reviewed-by on v2 2/2
#15 lore raw

Re: [PATCH v2 2/2] KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

Quoted 49 lines · Binbin Wu

Use is_kvm_hc_exit_enabled() instead of opencode.

No functional change intended.

---
 arch/x86/kvm/svm/sev.c | 4 ++--
 arch/x86/kvm/x86.c     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
arch/x86/kvm/svm/sev.c +2 -2
index a16c873b3232..d622aab8351d 100644
@@ -3635,7 +3635,7 @@ static int snp_begin_psc_msr(struct vcpu_svm *svm, u64 ghcb_msr)
 		return 1; /* resume guest */
 	}
 
-	if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE))) {
+	if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE)) {
 		set_ghcb_msr(svm, GHCB_MSR_PSC_RESP_ERROR);
 		return 1; /* resume guest */
 	}
@@ -3718,7 +3718,7 @@ static int snp_begin_psc(struct vcpu_svm *svm, struct psc_buffer *psc)
 	bool huge;
 	u64 gfn;
 
-	if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE))) {
+	if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE)) {
 		snp_complete_psc(svm, VMGEXIT_PSC_ERROR_GENERIC);
 		return 1;
 	}
arch/x86/kvm/x86.c +1 -1
index 6e16c9751af7..9857c1984ef7 100644
@@ -10171,7 +10171,7 @@ unsigned long __kvm_emulate_hypercall(struct kvm_vcpu *vcpu, unsigned long nr,
 		u64 gpa = a0, npages = a1, attrs = a2;
 
 		ret = -KVM_ENOSYS;
-		if (!(vcpu->kvm->arch.hypercall_exit_enabled & (1 << KVM_HC_MAP_GPA_RANGE)))
+		if (!is_kvm_hc_exit_enabled(vcpu->kvm, KVM_HC_MAP_GPA_RANGE))
 			break;
 
 		if (!PAGE_ALIGNED(gpa) || !npages ||
Signature · 1 line
2.43.2
Signature · 1 line
Isaku Yamahata <[email protected]>
Reviewed-by on v2 2/2
#16 lore raw

Re: [PATCH v2 2/2] KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

In reply to Binbin Wu
Quoted 3 lines · Binbin Wu

Use is_kvm_hc_exit_enabled() instead of opencode.

No functional change intended.

It would be helpful to mention currently hypercall_exit_enabled can only have KVM_HC_MAP_GPA_RANGE bit set (so that there will be no functional change).

Quoted 2 lines
author
#17 lore raw

Re: [PATCH v2 2/2] KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

Quoted 8 lines · Kai
Quoted 3 lines · Binbin Wu

Use is_kvm_hc_exit_enabled() instead of opencode.

No functional change intended.

It would be helpful to mention currently hypercall_exit_enabled can only have KVM_HC_MAP_GPA_RANGE bit set (so that there will be no functional change).

I think it's not needed, because is_kvm_hc_exit_enabled() takes the input. It just replaces the opencode with a helper API.

Maybe your comment was for the patch 1?

Quoted 6 lines
Quoted 3 lines

Thanks for your review.

#18 lore raw

Re: [PATCH v2 2/2] KVM: x86: Use is_kvm_hc_exit_enabled() instead of opencode

Quoted 9 lines · Binbin Wu
Quoted 5 lines · Kai
Quoted 2 lines · Binbin Wu

Use is_kvm_hc_exit_enabled() instead of opencode.

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

No functional change intended.

It would be helpful to mention currently hypercall_exit_enabled can only have KVM_HC_MAP_GPA_RANGE bit set (so that there will be no functional change).

I think it's not needed, because is_kvm_hc_exit_enabled() takes the input. It just replaces the opencode with a helper API.

Maybe your comment was for the patch 1?

OK. I guess my brain wasn't very clear, feel free to ignore :-)