Skip to contentSkip to conversation

x86/xsaves: Introduce a new check that allows correct xstates copy from kernel to user directly

PATCH Superseded Yu-cheng Yu 2 participants 4 messages Feb 22, 2016 x86

v1 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

PATCH 4/10 x86/xsaves: Introduce a new check that allows correct xstates copy from kernel to user directly

XSAVES is a kernel instruction and uses a compacted format. When working with user space, the kernel should provide standard-format, non-supervisor state data. We cannot do __copy_to_user() from a compacted- format kernel xstate area to a signal frame.

Note that the path to copy_fpstate_to_sigframe() does currently check if the thread has used FPU, but add a WARN_ONCE() there to detect any potential mis-use.

Dave Hansen proposes this method to simplify copy xstate directly to user.

Signed-off by: Yu-cheng Yu <[email protected]>

---
 arch/x86/kernel/fpu/signal.c | 41 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)
arch/x86/kernel/fpu/signal.c +40 -1
index 0fbf60c..7676718 100644
@@ -130,6 +130,45 @@ static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf)
 	return err;
 }
 
+static int should_save_registers_directly(void)
+{
+	/*
+	 * In signal handling path, the kernel already checks if
+	 * FPU instructions have been used before it calls
+	 * copy_fpstate_to_sigframe(). We check this here again
+	 * to detect any potential mis-use and saving invalid
+	 * register values directly to a signal frame.
+	 */
+	WARN_ONCE(!current->thread.fpu.fpstate_active,
+		  "direct FPU save with no math use\n");
+
+	/*
+	 * In the case that we are using a compacted kernel
+	 * xsave area, we can not copy the thread.fpu.state
+	 * directly to userspace and *must* save it from the
+	 * registers directly.
+	 */
+	if (boot_cpu_has(X86_FEATURE_XSAVES))
+		return 1;
+
+	/*
+	 * fpregs_active() means "Can I use the FPU hardware
+	 * without taking a device-not-available exception?" This
+	 * means that saving the registers directly will be
+	 * cheaper than copying their contents out of
+	 * thread.fpu.state.
+	 *
+	 * Note that fpregs_active() is inherently racy and may
+	 * become false at any time.  If this race happens, we
+	 * will take a harmless device-not-available exception
+	 * when we attempt the FPU save instruction.
+	 */
+	if (fpregs_active())
+		return 1;
+
+	return 0;
+}
+
 /*
  * Save the fpu, extended register state to the user signal frame.
  *
@@ -167,7 +206,7 @@ int copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size)
 			sizeof(struct user_i387_ia32_struct), NULL,
 			(struct _fpstate_32 __user *) buf) ? -1 : 1;
 
-	if (fpregs_active()) {
+	if (should_save_registers_directly()) {
 		/* Save the live register state to the user directly. */
 		if (copy_fpregs_to_sigframe(buf_fx))
 			return -1;
Signature · 1 line
1.9.1
#1 lore raw
Quoted 22 lines · Yu-cheng Yu

XSAVES is a kernel instruction and uses a compacted format. When working with user space, the kernel should provide standard-format, non-supervisor state data. We cannot do __copy_to_user() from a compacted- format kernel xstate area to a signal frame.

Note that the path to copy_fpstate_to_sigframe() does currently check if the thread has used FPU, but add a WARN_ONCE() there to detect any potential mis-use.

Dave Hansen proposes this method to simplify copy xstate directly to user.

Signed-off by: Yu-cheng Yu <[email protected]>

---
 arch/x86/kernel/fpu/signal.c | 41 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)
arch/x86/kernel/fpu/signal.c +0 -0
index 0fbf60c..7676718 100644

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 133

Quoted 4 lines
arch/x86/kernel/fpu/signal.c +1 -0
@@ -130,6 +130,45 @@ static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf)
        return err;
 }
 
+static int should_save_registers_directly(void)

I don't like the name of this function because:

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 143

Quoted 10 lines
arch/x86/kernel/fpu/signal.c +10 -0
+{
+       /*
+        * In signal handling path, the kernel already checks if
+        * FPU instructions have been used before it calls
+        * copy_fpstate_to_sigframe(). We check this here again
+        * to detect any potential mis-use and saving invalid
+        * register values directly to a signal frame.
+        */
+       WARN_ONCE(!current->thread.fpu.fpstate_active,
+                 "direct FPU save with no math use\n");

... Here "direct" seems to mean that we're asking whether to directly save ...

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 150

Quoted 7 lines
arch/x86/kernel/fpu/signal.c +7 -0
+
+       /*
+        * In the case that we are using a compacted kernel
+        * xsave area, we can not copy the thread.fpu.state
+        * directly to userspace and *must* save it from the
+        * registers directly.
+        */

... and here "directly" means *both* copying directly to userspace and saving using xsave directly.

So can you rename it to something with an obvious meaning like "may_memcpy_fpu_regs" or similar?

--Andy

#2 lore raw
Quoted 25 lines · Andy Lutomirski
Quoted 1 line

+static int should_save_registers_directly(void)

I don't like the name of this function because:

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 143

Quoted 10 lines
arch/x86/kernel/fpu/signal.c +10 -0
+{
+       /*
+        * In signal handling path, the kernel already checks if
+        * FPU instructions have been used before it calls
+        * copy_fpstate_to_sigframe(). We check this here again
+        * to detect any potential mis-use and saving invalid
+        * register values directly to a signal frame.
+        */
+       WARN_ONCE(!current->thread.fpu.fpstate_active,
+                 "direct FPU save with no math use\n");

... Here "direct" seems to mean that we're asking whether to directly save ...

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 150

Quoted 7 lines
arch/x86/kernel/fpu/signal.c +7 -0
+
+       /*
+        * In the case that we are using a compacted kernel
+        * xsave area, we can not copy the thread.fpu.state
+        * directly to userspace and *must* save it from the
+        * registers directly.
+        */
Quoted 5 lines

... and here "directly" means *both* copying directly to userspace and saving using xsave directly.

So can you rename it to something with an obvious meaning like "may_memcpy_fpu_regs" or similar?

This function determines whether the kernel should do copy_fpregs_to_sigframe(). Perhaps we can re-name it to may_copy_fpregs_to_sigframe()?

--Yu-cheng

#3 lore raw
Quoted 29 lines · Yu-cheng Yu
Quoted 28 lines · Andy Lutomirski
Quoted 1 line

+static int should_save_registers_directly(void)

I don't like the name of this function because:

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 143

Quoted 10 lines
arch/x86/kernel/fpu/signal.c +10 -0
+{
+       /*
+        * In signal handling path, the kernel already checks if
+        * FPU instructions have been used before it calls
+        * copy_fpstate_to_sigframe(). We check this here again
+        * to detect any potential mis-use and saving invalid
+        * register values directly to a signal frame.
+        */
+       WARN_ONCE(!current->thread.fpu.fpstate_active,
+                 "direct FPU save with no math use\n");

... Here "direct" seems to mean that we're asking whether to directly save ...

arch/x86/kernel/fpu/signal.c static inline int copy_fpregs_to_sigframe(struct xregs_state __user *buf) · line 150

Quoted 7 lines
arch/x86/kernel/fpu/signal.c +7 -0
+
+       /*
+        * In the case that we are using a compacted kernel
+        * xsave area, we can not copy the thread.fpu.state
+        * directly to userspace and *must* save it from the
+        * registers directly.
+        */

... and here "directly" means *both* copying directly to userspace and saving using xsave directly.

Quoted 7 lines
Quoted 2 lines

So can you rename it to something with an obvious meaning like "may_memcpy_fpu_regs" or similar?

This function determines whether the kernel should do copy_fpregs_to_sigframe(). Perhaps we can re-name it to may_copy_fpregs_to_sigframe()?

Works for me.

Quoted 2 lines

--Yu-cheng

Signature · 2 lines
Andy Lutomirski
AMA Capital Management, LLC