Commit 926b21f3 authored by Sebastian Andrzej Siewior's avatar Sebastian Andrzej Siewior Committed by Borislav Petkov
Browse files

x86/fpu: Restore from kernel memory on the 64-bit path too 



The 64-bit case (both 64-bit and 32-bit frames) loads the new state from
user memory.

However, doing this is not desired if the FPU state is going to be
restored on return to userland: it would be required to disable
preemption in order to avoid a context switch which would set
TIF_NEED_FPU_LOAD. If this happens before the restore operation then the
loaded registers would become volatile.

Furthermore, disabling preemption while accessing user memory requires
to disable the pagefault handler. An error during FXRSTOR would then
mean that either a page fault occurred (and it would have to be retried
with enabled page fault handler) or a #GP occurred because the xstate is
bogus (after all, the signal handler can modify it).

In order to avoid that mess, copy the FPU state from userland, validate
it and then load it. The copy_kernel_…() helpers are basically just
like the old helpers except that they operate on kernel memory and the
fault handler just sets the error value and the caller handles it.

copy_user_to_fpregs_zeroing() and its helpers remain and will be used
later for a fastpath optimisation.

 [ bp: Clarify commit message. ]

Signed-off-by: default avatarSebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: default avatarBorislav Petkov <bp@suse.de>
Reviewed-by: default avatarDave Hansen <dave.hansen@intel.com>
Reviewed-by: default avatarThomas Gleixner <tglx@linutronix.de>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Aubrey Li <aubrey.li@intel.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jann Horn <jannh@google.com>
Cc: "Jason A. Donenfeld" <Jason@zx2c4.com>
Cc: kvm ML <kvm@vger.kernel.org>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Radim Krčmář <rkrcmar@redhat.com>
Cc: Rik van Riel <riel@surriel.com>
Cc: x86-ml <x86@kernel.org>
Link: https://lkml.kernel.org/r/20190403164156.19645-22-bigeasy@linutronix.de
parent e0d3602f

arch/x86/include/asm/fpu/internal.h

+43 −0
Original line number Diff line number Diff line
@@ -121,6 +121,21 @@ extern void fpstate_sanitize_xstate(struct fpu *fpu); 
	err;								\

})



#define kernel_insn_err(insn, output, input...)				\

({									\

	int err;							\

	asm volatile("1:" #insn "\n\t"					\

		     "2:\n"						\

		     ".section .fixup,\"ax\"\n"				\

		     "3:  movl $-1,%[err]\n"				\

		     "    jmp  2b\n"					\

		     ".previous\n"					\

		     _ASM_EXTABLE(1b, 3b)				\

		     : [err] "=r" (err), output				\

		     : "0"(0), input);					\

	err;								\

})



#define kernel_insn(insn, output, input...)				\

	asm volatile("1:" #insn "\n\t"					\

		     "2:\n"						\
@@ -149,6 +164,14 @@ static inline void copy_kernel_to_fxregs(struct fxregs_state *fx) 
		kernel_insn(fxrstorq %[fx], "=m" (*fx), [fx] "m" (*fx));

}



static inline int copy_kernel_to_fxregs_err(struct fxregs_state *fx)

{

	if (IS_ENABLED(CONFIG_X86_32))

		return kernel_insn_err(fxrstor %[fx], "=m" (*fx), [fx] "m" (*fx));

	else

		return kernel_insn_err(fxrstorq %[fx], "=m" (*fx), [fx] "m" (*fx));

}



static inline int copy_user_to_fxregs(struct fxregs_state __user *fx)

{

	if (IS_ENABLED(CONFIG_X86_32))
@@ -162,6 +185,11 @@ static inline void copy_kernel_to_fregs(struct fregs_state *fx) 
	kernel_insn(frstor %[fx], "=m" (*fx), [fx] "m" (*fx));

}



static inline int copy_kernel_to_fregs_err(struct fregs_state *fx)

{

	return kernel_insn_err(frstor %[fx], "=m" (*fx), [fx] "m" (*fx));

}



static inline int copy_user_to_fregs(struct fregs_state __user *fx)

{

	return user_insn(frstor %[fx], "=m" (*fx), [fx] "m" (*fx));
@@ -361,6 +389,21 @@ static inline int copy_user_to_xregs(struct xregs_state __user *buf, u64 mask) 
	return err;

}



/*

 * Restore xstate from kernel space xsave area, return an error code instead of

 * an exception.

 */

static inline int copy_kernel_to_xregs_err(struct xregs_state *xstate, u64 mask)

{

	u32 lmask = mask;

	u32 hmask = mask >> 32;

	int err;



	XSTATE_OP(XRSTOR, xstate, lmask, hmask, err);



	return err;

}



/*

 * These must be called with preempt disabled. Returns

 * 'true' if the FPU state is still intact and we can

arch/x86/kernel/fpu/signal.c

+49 −13
Original line number Diff line number Diff line
@@ -234,6 +234,7 @@ sanitize_restored_xstate(union fpregs_state *state, 
		 */

		xsave->i387.mxcsr &= mxcsr_feature_mask;



		if (ia32_env)

			convert_to_fxsr(&state->fxsave, ia32_env);

	}

}
@@ -337,28 +338,63 @@ static int __fpu__restore_sig(void __user *buf, void __user *buf_fx, int size) 
		kfree(tmp);

		return err;

	} else {

		union fpregs_state *state;

		void *tmp;

		int ret;



		tmp = kzalloc(sizeof(*state) + fpu_kernel_xstate_size + 64, GFP_KERNEL);

		if (!tmp)

			return -ENOMEM;

		state = PTR_ALIGN(tmp, 64);



		/*

		 * For 64-bit frames and 32-bit fsave frames, restore the user

		 * state to the registers directly (with exceptions handled).

		 */

		if ((unsigned long)buf_fx % 64)

			fx_only = 1;



		if (use_xsave() && !fx_only) {

			u64 init_bv = xfeatures_mask & ~xfeatures;



			if (using_compacted_format()) {

				ret = copy_user_to_xstate(&state->xsave, buf_fx);

			} else {

				ret = __copy_from_user(&state->xsave, buf_fx, state_size);



				if (!ret && state_size > offsetof(struct xregs_state, header))

					ret = validate_xstate_header(&state->xsave.header);

			}

			if (ret)

				goto err_out;



			sanitize_restored_xstate(state, NULL, xfeatures, fx_only);



			if (unlikely(init_bv))

				copy_kernel_to_xregs(&init_fpstate.xsave, init_bv);

			ret = copy_kernel_to_xregs_err(&state->xsave, xfeatures);



		} else if (use_fxsr()) {

			ret = __copy_from_user(&state->fxsave, buf_fx, state_size);

			if (ret)

				goto err_out;



			if (use_xsave()) {

			if ((unsigned long)buf_fx % 64 || fx_only) {

				u64 init_bv = xfeatures_mask & ~XFEATURE_MASK_FPSSE;

				copy_kernel_to_xregs(&init_fpstate.xsave, init_bv);

				ret = copy_user_to_fxregs(buf_fx);

			}

			state->fxsave.mxcsr &= mxcsr_feature_mask;



			ret = copy_kernel_to_fxregs_err(&state->fxsave);

		} else {

				u64 init_bv = xfeatures_mask & ~xfeatures;

				if (unlikely(init_bv))

					copy_kernel_to_xregs(&init_fpstate.xsave, init_bv);

				ret = copy_user_to_xregs(buf_fx, xfeatures);

			ret = __copy_from_user(&state->fsave, buf_fx, state_size);

			if (ret)

				goto err_out;

			ret = copy_kernel_to_fregs_err(&state->fsave);

		}

		} else if (use_fxsr()) {

			ret = copy_user_to_fxregs(buf_fx);

		} else

			ret = copy_user_to_fregs(buf_fx);



err_out:

		kfree(tmp);

		if (ret) {

			fpu__clear(fpu);

			return -1;

CRA Git | Maintained and supported by SUSTech CRA and CCSE