Skip to contentSkip to conversation

xen/pv: sanitize xen pv guest msr accesses

PATCH Superseded Juergen Gross 3 participants 10 messages Oct 4, 2022

Subsystems (3)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Juergen Gross

author maintainer
#0 lore raw

v2 cover xen/pv: sanitize xen pv guest msr accesses

Historically when running as Xen PV guest all MSR accesses have been silently swallowing any GP faults, even when the kernel was using not the *msr_safe() access functions.

Change that by making the behavior controllable via kernel config and via a boot parameter.

This will help finding paths where MSRs are being accessed under Xen which are not emulated by the hypervisor.

Juergen Gross (3):
xen/pv: allow pmu msr accesses to cause GP
xen/pv: refactor msr access functions to support safe and unsafe
accesses
xen/pv: support selecting safe/unsafe msr accesses

 .../admin-guide/kernel-parameters.txt         |  6 ++
 arch/x86/xen/Kconfig                          |  9 ++
 arch/x86/xen/enlighten_pv.c                   | 99 +++++++++++++------
 arch/x86/xen/pmu.c                            | 61 ++++++------
 4 files changed, 118 insertions(+), 57 deletions(-)
Signature · 1 line
2.35.3
author maintainer
#1 lore raw

PATCH v2 1/3 xen/pv: allow pmu msr accesses to cause GP

Today pmu_msr_read() and pmu_msr_write() fall back to the safe variants of read/write MSR in case the MSR access isn't emulated via Xen. Allow the caller to select the potentially faulting variant by passing NULL for the error pointer.

Restructure the code to make it more readable.

---
V2:
- do some restructuring (Jan Beulich, Boris Ostrovsky)

---
 arch/x86/xen/pmu.c | 61 +++++++++++++++++++++++++---------------------
 1 file changed, 33 insertions(+), 28 deletions(-)
arch/x86/xen/pmu.c +33 -28
index 21ecbe754cb2..501b6f872d96 100644
@@ -131,6 +131,9 @@ static inline uint32_t get_fam15h_addr(u32 addr)
 
 static inline bool is_amd_pmu_msr(unsigned int msr)
 {
+	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
+		return false;
+
 	if ((msr >= MSR_F15H_PERF_CTL &&
 	     msr < MSR_F15H_PERF_CTR + (amd_num_counters * 2)) ||
 	    (msr >= MSR_K7_EVNTSEL0 &&
@@ -144,6 +147,9 @@ static int is_intel_pmu_msr(u32 msr_index, int *type, int *index)
 {
 	u32 msr_index_pmc;
 
+	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
+		return false;
+
 	switch (msr_index) {
 	case MSR_CORE_PERF_FIXED_CTR_CTRL:
 	case MSR_IA32_DS_AREA:
@@ -292,46 +298,45 @@ static bool xen_amd_pmu_emulate(unsigned int msr, u64 *val, bool is_read)
 
 bool pmu_msr_read(unsigned int msr, uint64_t *val, int *err)
 {
-	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-		if (is_amd_pmu_msr(msr)) {
-			if (!xen_amd_pmu_emulate(msr, val, 1))
-				*val = native_read_msr_safe(msr, err);
-			return true;
-		}
-	} else {
-		int type, index;
+	int type, index;
+	bool emulated;
 
-		if (is_intel_pmu_msr(msr, &type, &index)) {
-			if (!xen_intel_pmu_emulate(msr, val, type, index, 1))
-				*val = native_read_msr_safe(msr, err);
-			return true;
-		}
+	if (is_amd_pmu_msr(msr))
+		emulated = xen_amd_pmu_emulate(msr, val, 1);
+	else if (is_intel_pmu_msr(msr, &type, &index))
+		emulated = xen_intel_pmu_emulate(msr, val, type, index, 1);
+	else
+		return false;
+
+	if (!emulated) {
+		*val = err ? native_read_msr_safe(msr, err)
+			   : native_read_msr(msr);
 	}
 
-	return false;
+	return true;
 }
 
 bool pmu_msr_write(unsigned int msr, uint32_t low, uint32_t high, int *err)
 {
 	uint64_t val = ((uint64_t)high << 32) | low;
+	int type, index;
+	bool emulated;
 
-	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-		if (is_amd_pmu_msr(msr)) {
-			if (!xen_amd_pmu_emulate(msr, &val, 0))
-				*err = native_write_msr_safe(msr, low, high);
-			return true;
-		}
-	} else {
-		int type, index;
+	if (is_amd_pmu_msr(msr))
+		emulated = xen_amd_pmu_emulate(msr, &val, 0);
+	else if (is_intel_pmu_msr(msr, &type, &index))
+		emulated = xen_intel_pmu_emulate(msr, &val, type, index, 0);
+	else
+		return false;
 
-		if (is_intel_pmu_msr(msr, &type, &index)) {
-			if (!xen_intel_pmu_emulate(msr, &val, type, index, 0))
-				*err = native_write_msr_safe(msr, low, high);
-			return true;
-		}
+	if (!emulated) {
+		if (err)
+			*err = native_write_msr_safe(msr, low, high);
+		else
+			native_write_msr(msr, low, high);
 	}
 
-	return false;
+	return true;
 }
 
 static unsigned long long xen_amd_read_pmc(int counter)
Signature · 1 line
2.35.3
#2 lore raw

Re: [PATCH v2 1/3] xen/pv: allow pmu msr accesses to cause GP

Quoted 8 lines · Juergen Gross

Today pmu_msr_read() and pmu_msr_write() fall back to the safe variants of read/write MSR in case the MSR access isn't emulated via Xen. Allow the caller to select the potentially faulting variant by passing NULL for the error pointer.

Restructure the code to make it more readable.

I think the title (and to some degree also the description) is misleading:
The property we care about here isn't whether an MSR access would raise #GP (we can't control that), but whether that #GP would be recovered from.

arch/x86/xen/pmu.c static inline uint32_t get_fam15h_addr(u32 addr) · line 135

Quoted 8 lines
arch/x86/xen/pmu.c +2 -0
@@ -131,6 +131,9 @@ static inline uint32_t get_fam15h_addr(u32 addr)
 
 static inline bool is_amd_pmu_msr(unsigned int msr)
 {
+	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
+		return false;

I understand this and ...

arch/x86/xen/pmu.c static int is_intel_pmu_msr(u32 msr_index, int *type, int *index) · line 151

Quoted 6 lines
arch/x86/xen/pmu.c +2 -0
@@ -144,6 +147,9 @@ static int is_intel_pmu_msr(u32 msr_index, int *type, int *index)
 {
 	u32 msr_index_pmc;
 
+	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
+		return false;

... this matches prior behavior, but may I suggest that while moving these here you at least accompany them by a comment clarifying that these aren't really correct? We'd come closer if is_amd_pmu_msr() accepted AMD and Hygon, while is_intel_pmu_msr() may want to accept Intel and Centaur (but I understand this would be largely orthogonal, hence the suggestion towards comments). In the hypervisor we kind of also support Shanghai, but I wonder whether we wouldn't better rip out that code as unmaintained.

Jan

author maintainer
#3 lore raw

Re: [PATCH v2 1/3] xen/pv: allow pmu msr accesses to cause GP

Quoted 6 lines · Jan Beulich
Quoted 5 lines · Juergen Gross

Today pmu_msr_read() and pmu_msr_write() fall back to the safe variants of read/write MSR in case the MSR access isn't emulated via Xen. Allow the caller to select the potentially faulting variant by passing NULL for the error pointer.

Quoted 7 lines
Quoted 3 lines

Restructure the code to make it more readable.

I think the title (and to some degree also the description) is misleading:
The property we care about here isn't whether an MSR access would raise #GP (we can't control that), but whether that #GP would be recovered from.

Would you be fine with adding "fatal" or "visible"?

Quoted 16 lines

arch/x86/xen/pmu.c static inline uint32_t get_fam15h_addr(u32 addr) · line 135

Quoted 9 lines
arch/x86/xen/pmu.c +2 -0
@@ -131,6 +131,9 @@ static inline uint32_t get_fam15h_addr(u32 addr)
 
  static inline bool is_amd_pmu_msr(unsigned int msr)
  {
+	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
+		return false;

I understand this and ...

Quoted 4 lines
arch/x86/xen/pmu.c +0 -0
@@ -144,6 +147,9 @@ static int is_intel_pmu_msr(u32 msr_index, int *type, int *index)
  {
  	u32 msr_index_pmc;
 
Quoted 11 lines

arch/x86/xen/pmu.c static int is_intel_pmu_msr(u32 msr_index, int *type, int *index) · line 151

Quoted 2 lines
arch/x86/xen/pmu.c +2 -0
+	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
+		return false;

... this matches prior behavior, but may I suggest that while moving these here you at least accompany them by a comment clarifying that these aren't really correct? We'd come closer if is_amd_pmu_msr() accepted AMD and Hygon, while is_intel_pmu_msr() may want to accept Intel and Centaur (but I understand this would be largely orthogonal, hence the suggestion towards comments). In the hypervisor we kind of also support Shanghai, but I wonder whether we wouldn't better rip out that code as unmaintained.

Maybe the correct thing to do would be to add another patch to fix is_*_pmu_msr() along the lines you are suggesting.

Juergen

#4 lore raw

Re: [PATCH v2 1/3] xen/pv: allow pmu msr accesses to cause GP

Quoted 9 lines · Juergen Gross
Quoted 8 lines · Jan Beulich
Quoted 7 lines · Juergen Gross

Today pmu_msr_read() and pmu_msr_write() fall back to the safe variants of read/write MSR in case the MSR access isn't emulated via Xen. Allow the caller to select the potentially faulting variant by passing NULL for the error pointer.

Restructure the code to make it more readable.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

I think the title (and to some degree also the description) is misleading:
The property we care about here isn't whether an MSR access would raise #GP (we can't control that), but whether that #GP would be recovered from.

Would you be fine with adding "fatal" or "visible"?

That would help, but "allow" also is a little odd when it comes to (likely) crashing the system.

Jan

#5 lore raw

Re: [PATCH v2 1/3] xen/pv: allow pmu msr accesses to cause GP

In reply to Juergen Gross
Quoted 17 lines · Juergen Gross
  
  bool pmu_msr_read(unsigned int msr, uint64_t *val, int *err)
  {
arch/x86/xen/pmu.c +2 -11
-	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) {
-		if (is_amd_pmu_msr(msr)) {
-			if (!xen_amd_pmu_emulate(msr, val, 1))
-				*val = native_read_msr_safe(msr, err);
-			return true;
-		}
-	} else {
-		int type, index;
+	int type, index;
+	bool emulated;
 
-		if (is_intel_pmu_msr(msr, &type, &index)) {
-			if (!xen_intel_pmu_emulate(msr, val, type, index, 1))
-				*val = native_read_msr_safe(msr, err);

arch/x86/xen/pmu.c static bool xen_amd_pmu_emulate(unsigned int msr, u64 *val, bool is_read) · line 311

Quoted 10 lines
arch/x86/xen/pmu.c +8 -2
-			return true;
-		}
+	if (is_amd_pmu_msr(msr))
+		emulated = xen_amd_pmu_emulate(msr, val, 1);
+	else if (is_intel_pmu_msr(msr, &type, &index))
+		emulated = xen_intel_pmu_emulate(msr, val, type, index, 1);
+	else
+		return false;
+
+	if (!emulated) {

You can factor this out even further I think by moving if/elseif/esle into a separate routine and then have 'if (!xen_emulate_pmu_msr(msr, val, 1))' (and pass zero from pmu_msr_write())

-boris

author maintainer
#6 lore raw

PATCH v2 2/3 xen/pv: refactor msr access functions to support safe and unsafe accesses

In reply to Juergen Gross

Refactor and rename xen_read_msr_safe() and xen_write_msr_safe() to support both cases of MSR accesses, safe ones and potentially GP-fault generating ones.

This will prepare to no longer swallow GPs silently in xen_read_msr() and xen_write_msr().

---
V2:
- init val in xen_do_read_msr() to 0 (Jan Beulich)

---
 arch/x86/xen/enlighten_pv.c | 75 +++++++++++++++++++++++++++----------
 1 file changed, 56 insertions(+), 19 deletions(-)
arch/x86/xen/enlighten_pv.c +56 -19
index 9b1a58dda935..d5b0844a1b7c 100644
@@ -917,14 +917,18 @@ static void xen_write_cr4(unsigned long cr4)
 	native_write_cr4(cr4);
 }
 
-static u64 xen_read_msr_safe(unsigned int msr, int *err)
+static u64 xen_do_read_msr(unsigned int msr, int *err)
 {
-	u64 val;
+	u64 val = 0;	/* Avoid uninitialized value for safe variant. */
 
 	if (pmu_msr_read(msr, &val, err))
 		return val;
 
-	val = native_read_msr_safe(msr, err);
+	if (err)
+		val = native_read_msr_safe(msr, err);
+	else
+		val = native_read_msr(msr);
+
 	switch (msr) {
 	case MSR_IA32_APICBASE:
 		val &= ~X2APIC_ENABLE;
@@ -933,23 +937,39 @@ static u64 xen_read_msr_safe(unsigned int msr, int *err)
 	return val;
 }
 
-static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
+static void set_seg(unsigned int which, unsigned int low, unsigned int high,
+		    int *err)
 {
-	int ret;
-	unsigned int which;
-	u64 base;
+	u64 base = ((u64)high << 32) | low;
+
+	if (HYPERVISOR_set_segment_base(which, base) == 0)
+		return;
 
-	ret = 0;
+	if (err)
+		*err = -EIO;
+	else
+		WARN(1, "Xen set_segment_base(%u, %llx) failed\n", which, base);
+}
 
+/*
+ * Support write_msr_safe() and write_msr() semantics.
+ * With err == NULL write_msr() semantics are selected.
+ * Supplying an err pointer requires err to be pre-initialized with 0.
+ */
+static void xen_do_write_msr(unsigned int msr, unsigned int low,
+			     unsigned int high, int *err)
+{
 	switch (msr) {
-	case MSR_FS_BASE:		which = SEGBASE_FS; goto set;
-	case MSR_KERNEL_GS_BASE:	which = SEGBASE_GS_USER; goto set;
-	case MSR_GS_BASE:		which = SEGBASE_GS_KERNEL; goto set;
-
-	set:
-		base = ((u64)high << 32) | low;
-		if (HYPERVISOR_set_segment_base(which, base) != 0)
-			ret = -EIO;
+	case MSR_FS_BASE:
+		set_seg(SEGBASE_FS, low, high, err);
+		break;
+
+	case MSR_KERNEL_GS_BASE:
+		set_seg(SEGBASE_GS_USER, low, high, err);
+		break;
+
+	case MSR_GS_BASE:
+		set_seg(SEGBASE_GS_KERNEL, low, high, err);
 		break;
 
 	case MSR_STAR:
@@ -965,11 +985,28 @@ static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
 		break;
 
 	default:
-		if (!pmu_msr_write(msr, low, high, &ret))
-			ret = native_write_msr_safe(msr, low, high);
+		if (!pmu_msr_write(msr, low, high, err)) {
+			if (err)
+				*err = native_write_msr_safe(msr, low, high);
+			else
+				native_write_msr(msr, low, high);
+		}
 	}
+}
+
+static u64 xen_read_msr_safe(unsigned int msr, int *err)
+{
+	return xen_do_read_msr(msr, err);
+}
+
+static int xen_write_msr_safe(unsigned int msr, unsigned int low,
+			      unsigned int high)
+{
+	int err = 0;
+
+	xen_do_write_msr(msr, low, high, &err);
 
-	return ret;
+	return err;
 }
 
 static u64 xen_read_msr(unsigned int msr)
Signature · 1 line
2.35.3
Reviewed-by on v2 2/3
#7 lore raw

Re: [PATCH v2 2/3] xen/pv: refactor msr access functions to support safe and unsafe accesses

Quoted 8 lines · Juergen Gross

Refactor and rename xen_read_msr_safe() and xen_write_msr_safe() to support both cases of MSR accesses, safe ones and potentially GP-fault generating ones.

This will prepare to no longer swallow GPs silently in xen_read_msr() and xen_write_msr().

Albeit ...

Quoted 9 lines
arch/x86/xen/enlighten_pv.c +2 -2
@@ -933,23 +937,39 @@ static u64 xen_read_msr_safe(unsigned int msr, int *err)
 	return val;
 }
 
-static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
+static void set_seg(unsigned int which, unsigned int low, unsigned int high,
+		    int *err)
 {
-	int ret;

arch/x86/xen/enlighten_pv.c static u64 xen_read_msr_safe(unsigned int msr, int *err) · line 949

Quoted 10 lines
arch/x86/xen/enlighten_pv.c +6 -3
-	unsigned int which;
-	u64 base;
+	u64 base = ((u64)high << 32) | low;
+
+	if (HYPERVISOR_set_segment_base(which, base) == 0)
+		return;
 
-	ret = 0;
+	if (err)
+		*err = -EIO;

... I don't see a good reason to override the error code handed to us by the hypervisor here; I do realize though that this ...

Quoted 11 lines
arch/x86/xen/enlighten_pv.c +10 -0
+	else
+		WARN(1, "Xen set_segment_base(%u, %llx) failed\n", which, base);
+}
 
+/*
+ * Support write_msr_safe() and write_msr() semantics.
+ * With err == NULL write_msr() semantics are selected.
+ * Supplying an err pointer requires err to be pre-initialized with 0.
+ */
+static void xen_do_write_msr(unsigned int msr, unsigned int low,
+			     unsigned int high, int *err)

arch/x86/xen/enlighten_pv.c static u64 xen_read_msr_safe(unsigned int msr, int *err) · line 952

Quoted 10 lines
arch/x86/xen/enlighten_pv.c +1 -8
+{
 	switch (msr) {
-	case MSR_FS_BASE:		which = SEGBASE_FS; goto set;
-	case MSR_KERNEL_GS_BASE:	which = SEGBASE_GS_USER; goto set;
-	case MSR_GS_BASE:		which = SEGBASE_GS_KERNEL; goto set;
-
-	set:
-		base = ((u64)high << 32) | low;
-		if (HYPERVISOR_set_segment_base(which, base) != 0)
-			ret = -EIO;

... was this way before.

Jan

author maintainer
#8 lore raw

Re: [PATCH v2 2/3] xen/pv: refactor msr access functions to support safe and unsafe accesses

Quoted 52 lines · Jan Beulich
Quoted 8 lines · Juergen Gross

Refactor and rename xen_read_msr_safe() and xen_write_msr_safe() to support both cases of MSR accesses, safe ones and potentially GP-fault generating ones.

This will prepare to no longer swallow GPs silently in xen_read_msr() and xen_write_msr().

Albeit ...

Quoted 9 lines
arch/x86/xen/enlighten_pv.c +2 -2
@@ -933,23 +937,39 @@ static u64 xen_read_msr_safe(unsigned int msr, int *err)
  	return val;
  }
 
-static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
+static void set_seg(unsigned int which, unsigned int low, unsigned int high,
+		    int *err)
  {
-	int ret;

arch/x86/xen/enlighten_pv.c static u64 xen_read_msr_safe(unsigned int msr, int *err) · line 949

Quoted 10 lines
arch/x86/xen/enlighten_pv.c +6 -3
-	unsigned int which;
-	u64 base;
+	u64 base = ((u64)high << 32) | low;
+
+	if (HYPERVISOR_set_segment_base(which, base) == 0)
+		return;
 
-	ret = 0;
+	if (err)
+		*err = -EIO;

... I don't see a good reason to override the error code handed to us by the hypervisor here; I do realize though that this ...

Quoted 15 lines
arch/x86/xen/enlighten_pv.c +11 -2
+	else
+		WARN(1, "Xen set_segment_base(%u, %llx) failed\n", which, base);
+}
 
+/*
+ * Support write_msr_safe() and write_msr() semantics.
+ * With err == NULL write_msr() semantics are selected.
+ * Supplying an err pointer requires err to be pre-initialized with 0.
+ */
+static void xen_do_write_msr(unsigned int msr, unsigned int low,
+			     unsigned int high, int *err)
+{
  	switch (msr) {
-	case MSR_FS_BASE:		which = SEGBASE_FS; goto set;
-	case MSR_KERNEL_GS_BASE:	which = SEGBASE_GS_USER; goto set;
Quoted 8 lines

arch/x86/xen/enlighten_pv.c static u64 xen_read_msr_safe(unsigned int msr, int *err) · line 952

Quoted 6 lines
arch/x86/xen/enlighten_pv.c +0 -6
-	case MSR_GS_BASE:		which = SEGBASE_GS_KERNEL; goto set;
-
-	set:
-		base = ((u64)high << 32) | low;
-		if (HYPERVISOR_set_segment_base(which, base) != 0)
-			ret = -EIO;

... was this way before.

And on bare metal write_msr_safe() will return -EIO, too.

Juergen

author maintainer
#9 lore raw

PATCH v2 3/3 xen/pv: support selecting safe/unsafe msr accesses

In reply to Juergen Gross

Instead of always doing the safe variants for reading and writing MSRs in Xen PV guests, make the behavior controllable via Kconfig option and a boot parameter.

The default will be the current behavior, which is to always use the safe variant.

---
 .../admin-guide/kernel-parameters.txt         |  6 +++++
 arch/x86/xen/Kconfig                          |  9 +++++++
 arch/x86/xen/enlighten_pv.c                   | 24 +++++++++++--------
 3 files changed, 29 insertions(+), 10 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +6 -0
index 426fa892d311..1bda9cf18fae 100644
@@ -6836,6 +6836,12 @@
 			Crash from Xen panic notifier, without executing late
 			panic() code such as dumping handler.
 
+	xen_msr_safe=	[X86,XEN]
+			Format: <bool>
+			Select whether to always use non-faulting (safe) MSR
+			access functions when running as Xen PV guest. The
+			default value is controlled by CONFIG_XEN_PV_MSR_SAFE.
+
 	xen_nopvspin	[X86,XEN]
 			Disables the qspinlock slowpath using Xen PV optimizations.
 			This parameter is obsoleted by "nopvspin" parameter, which
arch/x86/xen/Kconfig +9 -0
index 85246dd9faa1..9b1ec5d8c99c 100644
@@ -92,3 +92,12 @@ config XEN_DOM0
 	select X86_X2APIC if XEN_PVH && X86_64
 	help
 	  Support running as a Xen Dom0 guest.
+
+config XEN_PV_MSR_SAFE
+	bool "Always use safe MSR accesses in PV guests"
+	default y
+	depends on XEN_PV
+	help
+	  Use safe (not faulting) MSR access functions even if the MSR access
+	  should not fault anyway.
+	  The default can be changed by using the "xen_msr_safe" boot parameter.
arch/x86/xen/enlighten_pv.c +14 -10
index d5b0844a1b7c..daae454191f2 100644
@@ -108,6 +108,16 @@ struct tls_descs {
  */
 static DEFINE_PER_CPU(struct tls_descs, shadow_tls_desc);
 
+static __read_mostly bool xen_msr_safe = IS_ENABLED(CONFIG_XEN_PV_MSR_SAFE);
+
+static int __init parse_xen_msr_safe(char *str)
+{
+	if (str)
+		return strtobool(str, &xen_msr_safe);
+	return -EINVAL;
+}
+early_param("xen_msr_safe", parse_xen_msr_safe);
+
 static void __init xen_pv_init_platform(void)
 {
 	/* PV guests can't operate virtio devices without grants. */
@@ -1011,22 +1021,16 @@ static int xen_write_msr_safe(unsigned int msr, unsigned int low,
 
 static u64 xen_read_msr(unsigned int msr)
 {
-	/*
-	 * This will silently swallow a #GP from RDMSR.  It may be worth
-	 * changing that.
-	 */
 	int err;
 
-	return xen_read_msr_safe(msr, &err);
+	return xen_do_read_msr(msr, xen_msr_safe ? &err : NULL);
 }
 
 static void xen_write_msr(unsigned int msr, unsigned low, unsigned high)
 {
-	/*
-	 * This will silently swallow a #GP from WRMSR.  It may be worth
-	 * changing that.
-	 */
-	xen_write_msr_safe(msr, low, high);
+	int err;
+
+	xen_do_write_msr(msr, low, high, xen_msr_safe ? &err : NULL);
 }
 
 /* This is called once we have the cpu_possible_mask */
Signature · 1 line
2.35.3