From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756416AbbEESSe (ORCPT ); Tue, 5 May 2015 14:18:34 -0400 Received: from mail-wg0-f49.google.com ([74.125.82.49]:36727 "EHLO mail-wg0-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1762248AbbEERxv (ORCPT ); Tue, 5 May 2015 13:53:51 -0400 From: Ingo Molnar To: linux-kernel@vger.kernel.org Cc: Andy Lutomirski , Borislav Petkov , Dave Hansen , Fenghua Yu , "H. Peter Anvin" , Linus Torvalds , Oleg Nesterov , Thomas Gleixner Subject: [PATCH 141/208] x86/fpu: Rename fpu__unlazy_stopped() to fpu__activate_stopped() Date: Tue, 5 May 2015 19:50:33 +0200 Message-Id: <1430848300-27877-63-git-send-email-mingo@kernel.org> X-Mailer: git-send-email 2.1.0 In-Reply-To: <1430848300-27877-1-git-send-email-mingo@kernel.org> References: <1430848300-27877-1-git-send-email-mingo@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org In line with the fpstate_activate() change, name fpu__unlazy_stopped() in a similar fashion as well: its purpose is to make the fpstate of a stopped task the current and active FPU context, which may require unlazying and initialization. The unlazying is just part of the job, the main concept is to make the fpstate active. Also clarify the function's description to clarify its exact usage and the background behind it all. Reviewed-by: Borislav Petkov Cc: Andy Lutomirski Cc: Dave Hansen Cc: Fenghua Yu Cc: H. Peter Anvin Cc: Linus Torvalds Cc: Oleg Nesterov Cc: Thomas Gleixner Signed-off-by: Ingo Molnar --- arch/x86/kernel/fpu/core.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/arch/x86/kernel/fpu/core.c b/arch/x86/kernel/fpu/core.c index 3221603d79bc..2fb7a77872cd 100644 --- a/arch/x86/kernel/fpu/core.c +++ b/arch/x86/kernel/fpu/core.c @@ -276,29 +276,30 @@ void fpu__activate_curr(struct fpu *fpu) EXPORT_SYMBOL_GPL(fpu__activate_curr); /* - * This function is called before we modify a stopped child's - * FPU state context. + * This function must be called before we modify a stopped child's + * fpstate. * * If the child has not used the FPU before then initialize its - * FPU context. + * fpstate. * * If the child has used the FPU before then unlazy it. * - * [ After this function call, after the context is modified and - * the child task is woken up, the child task will restore - * the modified FPU state from the modified context. If we + * [ After this function call, after registers in the fpstate are + * modified and the child task has woken up, the child task will + * restore the modified FPU state from the modified context. If we * didn't clear its lazy status here then the lazy in-registers - * state pending on its former CPU could be restored, losing + * state pending on its former CPU could be restored, corrupting * the modifications. ] * * This function is also called before we read a stopped child's - * FPU state - to make sure it's modified. + * FPU state - to make sure it's initialized if the child has + * no active FPU state. * * TODO: A future optimization would be to skip the unlazying in * the read-only case, it's not strictly necessary for * read-only access to the context. */ -static void fpu__unlazy_stopped(struct fpu *child_fpu) +static void fpu__activate_stopped(struct fpu *child_fpu) { WARN_ON_ONCE(child_fpu == ¤t->thread.fpu); @@ -388,7 +389,7 @@ int xfpregs_get(struct task_struct *target, const struct user_regset *regset, if (!cpu_has_fxsr) return -ENODEV; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); sanitize_i387_state(target); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, @@ -405,7 +406,7 @@ int xfpregs_set(struct task_struct *target, const struct user_regset *regset, if (!cpu_has_fxsr) return -ENODEV; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); sanitize_i387_state(target); ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, @@ -437,7 +438,7 @@ int xstateregs_get(struct task_struct *target, const struct user_regset *regset, if (!cpu_has_xsave) return -ENODEV; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); xsave = &fpu->state.xsave; @@ -466,7 +467,7 @@ int xstateregs_set(struct task_struct *target, const struct user_regset *regset, if (!cpu_has_xsave) return -ENODEV; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); xsave = &fpu->state.xsave; @@ -628,7 +629,7 @@ int fpregs_get(struct task_struct *target, const struct user_regset *regset, struct fpu *fpu = &target->thread.fpu; struct user_i387_ia32_struct env; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); if (!static_cpu_has(X86_FEATURE_FPU)) return fpregs_soft_get(target, regset, pos, count, kbuf, ubuf); @@ -658,7 +659,7 @@ int fpregs_set(struct task_struct *target, const struct user_regset *regset, struct user_i387_ia32_struct env; int ret; - fpu__unlazy_stopped(fpu); + fpu__activate_stopped(fpu); sanitize_i387_state(target); -- 2.1.0