1 files changed, 108 insertions, 55 deletions

diff --git a/arch/arm/vfp/vfpmodule.c b/arch/arm/vfp/vfpmodule.c
index 2d7423af1197..315a540c7ce5 100644
--- a/arch/arm/vfp/vfpmodule.c
+++ b/arch/arm/vfp/vfpmodule.c
@@ -38,16 +38,75 @@ union vfp_state *last_VFP_context[NR_CPUS];
  */
 unsigned int VFP_arch;
 
+/*
+ * Per-thread VFP initialization.
+ */
+static void vfp_thread_flush(struct thread_info *thread)
+{
+        union vfp_state *vfp = &thread->vfpstate;
+        unsigned int cpu;
+
+        memset(vfp, 0, sizeof(union vfp_state));
+
+        vfp->hard.fpexc = FPEXC_EN;
+        vfp->hard.fpscr = FPSCR_ROUND_NEAREST;
+
+        /*
+         * Disable VFP to ensure we initialize it first.  We must ensure
+         * that the modification of last_VFP_context[] and hardware disable
+         * are done for the same CPU and without preemption.
+         */
+        cpu = get_cpu();
+        if (last_VFP_context[cpu] == vfp)
+                last_VFP_context[cpu] = NULL;
+        fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
+        put_cpu();
+}
+
+static void vfp_thread_exit(struct thread_info *thread)
+{
+        /* release case: Per-thread VFP cleanup. */
+        union vfp_state *vfp = &thread->vfpstate;
+        unsigned int cpu = get_cpu();
+
+        if (last_VFP_context[cpu] == vfp)
+                last_VFP_context[cpu] = NULL;
+        put_cpu();
+}
+
+/*
+ * When this function is called with the following 'cmd's, the following
+ * is true while this function is being run:
+ *  THREAD_NOFTIFY_SWTICH:
+ *   - the previously running thread will not be scheduled onto another CPU.
+ *   - the next thread to be run (v) will not be running on another CPU.
+ *   - thread->cpu is the local CPU number
+ *   - not preemptible as we're called in the middle of a thread switch
+ *  THREAD_NOTIFY_FLUSH:
+ *   - the thread (v) will be running on the local CPU, so
+ *      v === current_thread_info()
+ *   - thread->cpu is the local CPU number at the time it is accessed,
+ *      but may change at any time.
+ *   - we could be preempted if tree preempt rcu is enabled, so
+ *      it is unsafe to use thread->cpu.
+ *  THREAD_NOTIFY_EXIT
+ *   - the thread (v) will be running on the local CPU, so
+ *      v === current_thread_info()
+ *   - thread->cpu is the local CPU number at the time it is accessed,
+ *      but may change at any time.
+ *   - we could be preempted if tree preempt rcu is enabled, so
+ *      it is unsafe to use thread->cpu.
+ */
 static int vfp_notifier(struct notifier_block *self, unsigned long cmd, void *v)
 {
         struct thread_info *thread = v;
-        union vfp_state *vfp;
-        __u32 cpu = thread->cpu;
 
         if (likely(cmd == THREAD_NOTIFY_SWITCH)) {
                 u32 fpexc = fmrx(FPEXC);
 
 #ifdef CONFIG_SMP
+                unsigned int cpu = thread->cpu;
+
                 /*
                  * On SMP, if VFP is enabled, save the old state in
                  * case the thread migrates to a different CPU. The
@@ -74,25 +133,10 @@ static int vfp_notifier(struct notifier_block *self, unsigned long cmd, void *v)
                 return NOTIFY_DONE;
         }
 
-        vfp = &thread->vfpstate;
-        if (cmd == THREAD_NOTIFY_FLUSH) {
-                /*
-                 * Per-thread VFP initialisation.
-                 */
-                memset(vfp, 0, sizeof(union vfp_state));
-
-                vfp->hard.fpexc = FPEXC_EN;
-                vfp->hard.fpscr = FPSCR_ROUND_NEAREST;
-
-                /*
-                 * Disable VFP to ensure we initialise it first.
-                 */
-                fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
-        }
-
-        /* flush and release case: Per-thread VFP cleanup. */
-        if (last_VFP_context[cpu] == vfp)
-                last_VFP_context[cpu] = NULL;
+        if (cmd == THREAD_NOTIFY_FLUSH)
+                vfp_thread_flush(thread);
+        else
+                vfp_thread_exit(thread);
 
         return NOTIFY_DONE;
 }
@@ -153,10 +197,13 @@ static void vfp_raise_exceptions(u32 exceptions, u32 inst, u32 fpscr, struct pt_
         }
 
         /*
-         * Update the FPSCR with the additional exception flags.
+         * If any of the status flags are set, update the FPSCR.
          * Comparison instructions always return at least one of
          * these flags set.
          */
+        if (exceptions & (FPSCR_N|FPSCR_Z|FPSCR_C|FPSCR_V))
+                fpscr &= ~(FPSCR_N|FPSCR_Z|FPSCR_C|FPSCR_V);
+
         fpscr |= exceptions;
 
         fmxr(FPSCR, fpscr);
@@ -381,54 +428,60 @@ static void vfp_pm_init(void)
 static inline void vfp_pm_init(void) { }
 #endif /* CONFIG_PM */
 
-/*
- * Synchronise the hardware VFP state of a thread other than current with the
- * saved one. This function is used by the ptrace mechanism.
- */
-#ifdef CONFIG_SMP
-void vfp_sync_state(struct thread_info *thread)
+void vfp_sync_hwstate(struct thread_info *thread)
 {
+        unsigned int cpu = get_cpu();
+
         /*
-         * On SMP systems, the VFP state is automatically saved at every
-         * context switch. We mark the thread VFP state as belonging to a
-         * non-existent CPU so that the saved one will be reloaded when
-         * needed.
+         * If the thread we're interested in is the current owner of the
+         * hardware VFP state, then we need to save its state.
          */
-        thread->vfpstate.hard.cpu = NR_CPUS;
+        if (last_VFP_context[cpu] == &thread->vfpstate) {
+                u32 fpexc = fmrx(FPEXC);
+
+                /*
+                 * Save the last VFP state on this CPU.
+                 */
+                fmxr(FPEXC, fpexc | FPEXC_EN);
+                vfp_save_state(&thread->vfpstate, fpexc | FPEXC_EN);
+                fmxr(FPEXC, fpexc);
+        }
+
+        put_cpu();
 }
-#else
-void vfp_sync_state(struct thread_info *thread)
+
+void vfp_flush_hwstate(struct thread_info *thread)
 {
         unsigned int cpu = get_cpu();
-        u32 fpexc = fmrx(FPEXC);
 
         /*
-         * If VFP is enabled, the previous state was already saved and
-         * last_VFP_context updated.
+         * If the thread we're interested in is the current owner of the
+         * hardware VFP state, then we need to save its state.
          */
-        if (fpexc & FPEXC_EN)
-                goto out;
+        if (last_VFP_context[cpu] == &thread->vfpstate) {
+                u32 fpexc = fmrx(FPEXC);
 
-        if (!last_VFP_context[cpu])
-                goto out;
+                fmxr(FPEXC, fpexc & ~FPEXC_EN);
 
-        /*
-         * Save the last VFP state on this CPU.
-         */
-        fmxr(FPEXC, fpexc | FPEXC_EN);
-        vfp_save_state(last_VFP_context[cpu], fpexc);
-        fmxr(FPEXC, fpexc);
+                /*
+                 * Set the context to NULL to force a reload the next time
+                 * the thread uses the VFP.
+                 */
+                last_VFP_context[cpu] = NULL;
+        }
 
+#ifdef CONFIG_SMP
         /*
-         * Set the context to NULL to force a reload the next time the thread
-         * uses the VFP.
+         * For SMP we still have to take care of the case where the thread
+         * migrates to another CPU and then back to the original CPU on which
+         * the last VFP user is still the same thread. Mark the thread VFP
+         * state as belonging to a non-existent CPU so that the saved one will
+         * be reloaded in the above case.
          */
-        last_VFP_context[cpu] = NULL;
-
-out:
+        thread->vfpstate.hard.cpu = NR_CPUS;
+#endif
         put_cpu();
 }
-#endif
 
 #include <linux/smp.h>
 
@@ -481,7 +534,7 @@ static int __init vfp_init(void)
                  */
                 elf_hwcap |= HWCAP_VFP;
 #ifdef CONFIG_VFPv3
-                if (VFP_arch >= 3) {
+                if (VFP_arch >= 2) {
                         elf_hwcap |= HWCAP_VFPv3;
 
                         /*