tsk->thread.fault_address = (__force unsigned int)addr;
 
-               force_sig_fault(signo, si_code, addr, tsk);
+               force_sig_fault(signo, si_code, addr, current);
 
        } else {
                /* If not due to copy_(to|from)_user, we are doomed */
 
        /* User mode accesses just cause a SIGSEGV */
        if (user_mode(regs)) {
                tsk->thread.fault_address = address;
-               force_sig_fault(SIGSEGV, si_code, (void __user *)address, tsk);
+               force_sig_fault(SIGSEGV, si_code, (void __user *)address, current);
                return;
        }
 
                goto no_context;
 
        tsk->thread.fault_address = address;
-       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, tsk);
+       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current);
 }
 
        tsk->thread.address = addr;
        tsk->thread.error_code = fsr;
        tsk->thread.trap_no = 14;
-       force_sig_fault(sig, code, (void __user *)addr, tsk);
+       force_sig_fault(sig, code, (void __user *)addr, current);
 }
 
 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
 
                        pr_cont("\n");
                }
                current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f;
-               force_sig_fault(SIGSEGV, si_code, (void __user *)address, tsk);
+               force_sig_fault(SIGSEGV, si_code, (void __user *)address, current);
                return;
        }
 
 #endif
        current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f;
        tsk->thread.cp0_badvaddr = address;
-       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, tsk);
+       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current);
 
        return;
 #ifndef CONFIG_64BIT
 
        tsk->thread.error_code = error_code;
 
        force_sig_fault(SIGTRAP, si_code,
-                       (void __user *)instruction_pointer(regs), tsk);
+                       (void __user *)instruction_pointer(regs), current);
 }
 
 void do_debug_trap(unsigned long entry, unsigned long addr,
 
                tsk->thread.address = addr;
                tsk->thread.error_code = error_code;
                tsk->thread.trap_no = entry;
-               force_sig_fault(SIGSEGV, si_code, (void __user *)addr, tsk);
+               force_sig_fault(SIGSEGV, si_code, (void __user *)addr, current);
                return;
        }
 
        tsk->thread.address = addr;
        tsk->thread.error_code = error_code;
        tsk->thread.trap_no = entry;
-       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)addr, tsk);
+       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)addr, current);
 
        return;
 
 
        /* User mode accesses just cause a SIGSEGV */
 
        if (user_mode(regs)) {
-               force_sig_fault(SIGSEGV, si_code, (void __user *)address, tsk);
+               force_sig_fault(SIGSEGV, si_code, (void __user *)address, current);
                return;
        }
 
         * Send a sigbus, regardless of whether we were in kernel
         * or user mode.
         */
-       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, tsk);
+       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current);
 
        /* Kernel mode? Handle exceptions or die */
        if (!user_mode(regs))
 
                show_regs(regs);
        }
 
-       force_sig_fault(signo, code, (void __user *)addr, tsk);
+       force_sig_fault(signo, code, (void __user *)addr, current);
 }
 
 static void do_trap_error(struct pt_regs *regs, int signo, int code,
 
                        task_thread_info(tsk)->status |= TS_USEDFPU;
                } else {
                        force_sig_fault(SIGFPE, FPE_FLTINV,
-                                       (void __user *)regs->pc, tsk);
+                                       (void __user *)regs->pc, current);
                }
 
                regs->pc = nextpc;
 
        tsk->thread.address = addr;
        tsk->thread.error_code = fsr;
        tsk->thread.trap_no = 14;
-       force_sig_fault(sig, code, (void __user *)addr, tsk);
+       force_sig_fault(sig, code, (void __user *)addr, current);
 }
 
 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
 
 
        /* Send us the fake SIGTRAP */
        force_sig_fault(SIGTRAP, si_code,
-                       user_mode(regs) ? (void __user *)regs->ip : NULL, tsk);
+                       user_mode(regs) ? (void __user *)regs->ip : NULL, current);
 }
 
 void user_single_step_report(struct pt_regs *regs)
 
        if (!sicode)
                force_sig(signr);
        else
-               force_sig_fault(signr, sicode, addr, tsk);
+               force_sig_fault(signr, sicode, addr, current);
 }
 NOKPROBE_SYMBOL(do_trap);
 
                return;
 
        force_sig_fault(SIGFPE, si_code,
-                       (void __user *)uprobe_get_trap_addr(regs), task);
+                       (void __user *)uprobe_get_trap_addr(regs), current);
 }
 
 dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code)
 
        tsk->thread.error_code  = X86_PF_USER | X86_PF_WRITE;
        tsk->thread.trap_nr     = X86_TRAP_PF;
 
-       force_sig_fault(SIGSEGV, SEGV_MAPERR, addr, tsk);
+       force_sig_fault(SIGSEGV, SEGV_MAPERR, addr, current);
 
        if (!(show_unhandled_signals && unhandled_signal(tsk, SIGSEGV)))
                return;
 
 
                        /* XXX: hwpoison faults will set the wrong code. */
                        force_sig_fault(signal, si_code, (void __user *)address,
-                                       tsk);
+                                       current);
                }
 
                /*
                if (si_code == SEGV_PKUERR)
                        force_sig_pkuerr((void __user *)address, pkey);
 
-               force_sig_fault(SIGSEGV, si_code, (void __user *)address, tsk);
+               force_sig_fault(SIGSEGV, si_code, (void __user *)address, current);
 
                return;
        }
                return;
        }
 #endif
-       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, tsk);
+       force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current);
 }
 
 static noinline void