3 files changed, 29 insertions, 55 deletions

diff --git a/arch/sparc64/kernel/smp.c b/arch/sparc64/kernel/smp.c
index b137fd63f5e1..a9089e2140e9 100644
--- a/arch/sparc64/kernel/smp.c
+++ b/arch/sparc64/kernel/smp.c
@@ -883,34 +883,13 @@ void smp_flush_tlb_pending(struct mm_struct *mm, unsigned long nr, unsigned long
         u32 ctx = CTX_HWBITS(mm->context);
         int cpu = get_cpu();
 
-        if (mm == current->active_mm && atomic_read(&mm->mm_users) == 1) {
+        if (mm == current->active_mm && atomic_read(&mm->mm_users) == 1)
                 mm->cpu_vm_mask = cpumask_of_cpu(cpu);
-                goto local_flush_and_out;
-        } else {
-                /* This optimization is not valid.  Normally
-                 * we will be holding the page_table_lock, but
-                 * there is an exception which is copy_page_range()
-                 * when forking.  The lock is held during the individual
-                 * page table updates in the parent, but not at the
-                 * top level, which is where we are invoked.
-                 */
-                if (0) {
-                        cpumask_t this_cpu_mask = cpumask_of_cpu(cpu);
-
-                        /* By virtue of running under the mm->page_table_lock,
-                         * and mmu_context.h:switch_mm doing the same, the
-                         * following operation is safe.
-                         */
-                        if (cpus_equal(mm->cpu_vm_mask, this_cpu_mask))
-                                goto local_flush_and_out;
-                }
-        }
-
-        smp_cross_call_masked(&xcall_flush_tlb_pending,
-                              ctx, nr, (unsigned long) vaddrs,
-                              mm->cpu_vm_mask);
+        else
+                smp_cross_call_masked(&xcall_flush_tlb_pending,
+                                      ctx, nr, (unsigned long) vaddrs,
+                                      mm->cpu_vm_mask);
 
-local_flush_and_out:
         __flush_tlb_pending(ctx, nr, vaddrs);
 
         put_cpu();
diff --git a/include/asm-sparc64/mmu_context.h b/include/asm-sparc64/mmu_context.h
index 87c43c67866e..08ba72d7722c 100644
--- a/include/asm-sparc64/mmu_context.h
+++ b/include/asm-sparc64/mmu_context.h
@@ -87,37 +87,35 @@ extern void __flush_tlb_mm(unsigned long, unsigned long);
 static inline void switch_mm(struct mm_struct *old_mm, struct mm_struct *mm, struct task_struct *tsk)
 {
         unsigned long ctx_valid;
+        int cpu;
 
+        /* Note: page_table_lock is used here to serialize switch_mm
+         * and activate_mm, and their calls to get_new_mmu_context.
+         * This use of page_table_lock is unrelated to its other uses.
+         */ 
         spin_lock(&mm->page_table_lock);
-        if (CTX_VALID(mm->context))
-                ctx_valid = 1;
-        else
-                ctx_valid = 0;
+        ctx_valid = CTX_VALID(mm->context);
+        if (!ctx_valid)
+                get_new_mmu_context(mm);
+        spin_unlock(&mm->page_table_lock);
 
         if (!ctx_valid || (old_mm != mm)) {
-                if (!ctx_valid)
-                        get_new_mmu_context(mm);
-
                 load_secondary_context(mm);
                 reload_tlbmiss_state(tsk, mm);
         }
 
-        {
-                int cpu = smp_processor_id();
-
-                /* Even if (mm == old_mm) we _must_ check
-                 * the cpu_vm_mask.  If we do not we could
-                 * corrupt the TLB state because of how
-                 * smp_flush_tlb_{page,range,mm} on sparc64
-                 * and lazy tlb switches work. -DaveM
-                 */
-                if (!ctx_valid || !cpu_isset(cpu, mm->cpu_vm_mask)) {
-                        cpu_set(cpu, mm->cpu_vm_mask);
-                        __flush_tlb_mm(CTX_HWBITS(mm->context),
-                                       SECONDARY_CONTEXT);
-                }
+        /* Even if (mm == old_mm) we _must_ check
+         * the cpu_vm_mask.  If we do not we could
+         * corrupt the TLB state because of how
+         * smp_flush_tlb_{page,range,mm} on sparc64
+         * and lazy tlb switches work. -DaveM
+         */
+        cpu = smp_processor_id();
+        if (!ctx_valid || !cpu_isset(cpu, mm->cpu_vm_mask)) {
+                cpu_set(cpu, mm->cpu_vm_mask);
+                __flush_tlb_mm(CTX_HWBITS(mm->context),
+                               SECONDARY_CONTEXT);
         }
-        spin_unlock(&mm->page_table_lock);
 }
 
 #define deactivate_mm(tsk,mm)   do { } while (0)
@@ -127,6 +125,10 @@ static inline void activate_mm(struct mm_struct *active_mm, struct mm_struct *mm
 {
         int cpu;
 
+        /* Note: page_table_lock is used here to serialize switch_mm
+         * and activate_mm, and their calls to get_new_mmu_context.
+         * This use of page_table_lock is unrelated to its other uses.
+         */ 
         spin_lock(&mm->page_table_lock);
         if (!CTX_VALID(mm->context))
                 get_new_mmu_context(mm);
diff --git a/kernel/fork.c b/kernel/fork.c
index efac2c58ec7d..158710d22566 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -470,13 +470,6 @@ static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
         if (clone_flags & CLONE_VM) {
                 atomic_inc(&oldmm->mm_users);
                 mm = oldmm;
-                /*
-                 * There are cases where the PTL is held to ensure no
-                 * new threads start up in user mode using an mm, which
-                 * allows optimizing out ipis; the tlb_gather_mmu code
-                 * is an example.
-                 */
-                spin_unlock_wait(&oldmm->page_table_lock);
                 goto good_mm;
         }