273 files changed, 1375 insertions, 4221 deletions
diff --git a/arch/Kconfig b/arch/Kconfig
index cc74aaea116c..34884faf98cd 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -342,4 +342,18 @@ config MODULES_USE_ELF_REL
          Modules only use ELF REL relocations.  Modules with ELF RELA
          relocations will give an error.
+#
+# ABI hall of shame
+#
+config CLONE_BACKWARDS
+        bool
+        help
+          Architecture has tls passed as the 4th argument of clone(2),
+          not the 5th one.
+config CLONE_BACKWARDS2
+        bool
+        help
+          Architecture has the first two arguments of clone(2) swapped.
 source "kernel/gcov/Kconfig"
diff --git a/arch/alpha/include/asm/ptrace.h b/arch/alpha/include/asm/ptrace.h
index b87755a19554..b4c5b2fbb647 100644
--- a/arch/alpha/include/asm/ptrace.h
+++ b/arch/alpha/include/asm/ptrace.h
@@ -78,6 +78,7 @@ struct switch_stack {
 #define current_pt_regs() \
  ((struct pt_regs *) ((char *)current_thread_info() + 2*PAGE_SIZE) - 1)
+#define signal_pt_regs current_pt_regs
 #define force_successful_syscall_return() (current_pt_regs()->r0 = 0)
diff --git a/arch/alpha/include/asm/signal.h b/arch/alpha/include/asm/signal.h
index a9388300abb1..45552862cc10 100644
--- a/arch/alpha/include/asm/signal.h
+++ b/arch/alpha/include/asm/signal.h
@@ -164,9 +164,6 @@ struct sigstack {
 #ifdef __KERNEL__
 #include <asm/sigcontext.h>
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif
 #endif
diff --git a/arch/alpha/include/asm/unistd.h b/arch/alpha/include/asm/unistd.h
index 7826e227e4d0..eb3a4664ced2 100644
--- a/arch/alpha/include/asm/unistd.h
+++ b/arch/alpha/include/asm/unistd.h
@@ -482,6 +482,9 @@
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /* "Conditional" syscalls.  What we want is
diff --git a/arch/alpha/kernel/binfmt_loader.c b/arch/alpha/kernel/binfmt_loader.c
index d1f474d1d44d..9525660c93c0 100644
--- a/arch/alpha/kernel/binfmt_loader.c
+++ b/arch/alpha/kernel/binfmt_loader.c
@@ -5,7 +5,7 @@
 #include <linux/binfmts.h>
 #include <linux/a.out.h>
-static int load_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+static int load_binary(struct linux_binprm *bprm)
 {
        struct exec *eh = (struct exec *)bprm->buf;
        unsigned long loader;
@@ -37,7 +37,7 @@ static int load_binary(struct linux_binprm *bprm, struct pt_regs *regs)
        retval = prepare_binprm(bprm);
        if (retval < 0)
                return retval;
-        return search_binary_handler(bprm,regs);
+        return search_binary_handler(bprm);
 }
 static struct linux_binfmt loader_format = {
diff --git a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S
index a7607832dd4f..f62a994ef126 100644
--- a/arch/alpha/kernel/entry.S
+++ b/arch/alpha/kernel/entry.S
@@ -612,47 +612,24 @@ ret_from_kernel_thread:
 * Special system calls.  Most of these are special in that they either
 * have to play switch_stack games or in some way use the pt_regs struct.
 */
-        .align  4
-        .globl  sys_fork
-        .ent    sys_fork
-sys_fork:
-        .prologue 0
-        mov     $sp, $21
-        bsr     $1, do_switch_stack
-        bis     $31, SIGCHLD, $16
-        mov     $31, $17
-        mov     $31, $18
-        mov     $31, $19
-        mov     $31, $20
-        jsr     $26, alpha_clone
-        bsr     $1, undo_switch_stack
-        ret
-.end sys_fork
+.macro  fork_like name
        .align  4
-        .globl  sys_clone
+        .globl  alpha_\name
-        .ent    sys_clone
+        .ent    alpha_\name
-sys_clone:
+alpha_\name:
        .prologue 0
-        mov     $sp, $21
        bsr     $1, do_switch_stack
-        /* $16, $17, $18, $19, $20 come from the user.  */
+        jsr     $26, sys_\name
-        jsr     $26, alpha_clone
+        ldq     $26, 56($sp)
-        bsr     $1, undo_switch_stack
+        lda     $sp, SWITCH_STACK_SIZE($sp)
        ret
-.end sys_clone
+.end    alpha_\name
+.endm
-        .align  4
+fork_like fork
-        .globl  sys_vfork
+fork_like vfork
-        .ent    sys_vfork
+fork_like clone
-sys_vfork:
-        .prologue 0
-        mov     $sp, $16
-        bsr     $1, do_switch_stack
-        jsr     $26, alpha_vfork
-        bsr     $1, undo_switch_stack
-        ret
-.end sys_vfork
        .align  4
        .globl  sys_sigreturn
@@ -661,8 +638,6 @@ sys_sigreturn:
        .prologue 0
        lda     $9, ret_from_straced
        cmpult  $26, $9, $9
-        mov     $sp, $17
-        lda     $18, -SWITCH_STACK_SIZE($sp)
        lda     $sp, -SWITCH_STACK_SIZE($sp)
        jsr     $26, do_sigreturn
        bne     $9, 1f
@@ -678,8 +653,6 @@ sys_rt_sigreturn:
        .prologue 0
        lda     $9, ret_from_straced
        cmpult  $26, $9, $9
-        mov     $sp, $17
-        lda     $18, -SWITCH_STACK_SIZE($sp)
        lda     $sp, -SWITCH_STACK_SIZE($sp)
        jsr     $26, do_rt_sigreturn
        bne     $9, 1f
diff --git a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c
index 51987dcf79b8..b5d0d0923699 100644
--- a/arch/alpha/kernel/process.c
+++ b/arch/alpha/kernel/process.c
@@ -235,51 +235,28 @@ release_thread(struct task_struct *dead_task)
 }
 /*
- * "alpha_clone()".. By the time we get here, the
- * non-volatile registers have also been saved on the
- * stack. We do some ugly pointer stuff here.. (see
- * also copy_thread)
- *
- * Notice that "fork()" is implemented in terms of clone,
- * with parameters (SIGCHLD, 0).
- */
-int
-alpha_clone(unsigned long clone_flags, unsigned long usp,
-            int __user *parent_tid, int __user *child_tid,
-            unsigned long tls_value, struct pt_regs *regs)
-{
-        if (!usp)
-                usp = rdusp();
-        return do_fork(clone_flags, usp, regs, 0, parent_tid, child_tid);
-}
-int
-alpha_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(),
-                       regs, 0, NULL, NULL);
-}
-/*
 * Copy an alpha thread..
 */
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
            unsigned long arg,
-            struct task_struct * p, struct pt_regs * regs)
+            struct task_struct *p)
 {
        extern void ret_from_fork(void);
        extern void ret_from_kernel_thread(void);
        struct thread_info *childti = task_thread_info(p);
        struct pt_regs *childregs = task_pt_regs(p);
+        struct pt_regs *regs = current_pt_regs();
        struct switch_stack *childstack, *stack;
        unsigned long settls;
        childstack = ((struct switch_stack *) childregs) - 1;
-        if (unlikely(!regs)) {
+        childti->pcb.ksp = (unsigned long) childstack;
+        childti->pcb.flags = 1; /* set FEN, clear everything else */
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* kernel thread */
                memset(childstack, 0,
                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
@@ -288,12 +265,17 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
                childstack->r10 = arg;
                childregs->hae = alpha_mv.hae_cache,
                childti->pcb.usp = 0;
-                childti->pcb.ksp = (unsigned long) childstack;
-                childti->pcb.flags = 1; /* set FEN, clear everything else */
                return 0;
        }
+        /* Note: if CLONE_SETTLS is not set, then we must inherit the
+           value from the parent, which will have been set by the block
+           copy in dup_task_struct.  This is non-intuitive, but is
+           required for proper operation in the case of a threaded
+           application calling fork.  */
+        if (clone_flags & CLONE_SETTLS)
+                childti->pcb.unique = regs->r20;
+        childti->pcb.usp = usp ?: rdusp();
        *childregs = *regs;
-        settls = regs->r20;
        childregs->r0 = 0;
        childregs->r19 = 0;
        childregs->r20 = 1;     /* OSF/1 has some strange fork() semantics.  */
@@ -301,22 +283,6 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
        stack = ((struct switch_stack *) regs) - 1;
        *childstack = *stack;
        childstack->r26 = (unsigned long) ret_from_fork;
-        childti->pcb.usp = usp;
-        childti->pcb.ksp = (unsigned long) childstack;
-        childti->pcb.flags = 1; /* set FEN, clear everything else */
-        /* Set a new TLS for the child thread?  Peek back into the
-           syscall arguments that we saved on syscall entry.  Oops,
-           except we'd have clobbered it with the parent/child set
-           of r20.  Read the saved copy.  */
-        /* Note: if CLONE_SETTLS is not set, then we must inherit the
-           value from the parent, which will have been set by the block
-           copy in dup_task_struct.  This is non-intuitive, but is
-           required for proper operation in the case of a threaded
-           application calling fork.  */
-        if (clone_flags & CLONE_SETTLS)
-                childti->pcb.unique = settls;
        return 0;
 }
diff --git a/arch/alpha/kernel/signal.c b/arch/alpha/kernel/signal.c
index 32575f85507d..336393c9c11f 100644
--- a/arch/alpha/kernel/signal.c
+++ b/arch/alpha/kernel/signal.c
@@ -160,10 +160,10 @@ extern char compile_time_assert
 #define INSN_CALLSYS            0x00000083
 static long
-restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
+restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
-                   struct switch_stack *sw)
 {
        unsigned long usp;
+        struct switch_stack *sw = (struct switch_stack *)regs - 1;
        long i, err = __get_user(regs->pc, &sc->sc_pc);
        current_thread_info()->restart_block.fn = do_no_restart_syscall;
@@ -215,9 +215,9 @@ restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
   registers and transfer control from userland.  */
 asmlinkage void
-do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
+do_sigreturn(struct sigcontext __user *sc)
-             struct switch_stack *sw)
 {
+        struct pt_regs *regs = current_pt_regs();
        sigset_t set;
        /* Verify that it's a good sigcontext before using it */
@@ -228,7 +228,7 @@ do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
        set_current_blocked(&set);
-        if (restore_sigcontext(sc, regs, sw))
+        if (restore_sigcontext(sc, regs))
                goto give_sigsegv;
        /* Send SIGTRAP if we're single-stepping: */
@@ -249,9 +249,9 @@ give_sigsegv:
 }
 asmlinkage void
-do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
+do_rt_sigreturn(struct rt_sigframe __user *frame)
-                struct switch_stack *sw)
 {
+        struct pt_regs *regs = current_pt_regs();
        sigset_t set;
        /* Verify that it's a good ucontext_t before using it */
@@ -262,7 +262,7 @@ do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
        set_current_blocked(&set);
-        if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
+        if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
                goto give_sigsegv;
        /* Send SIGTRAP if we're single-stepping: */
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S
index 2ac6b45c3e00..4284ec798ec9 100644
--- a/arch/alpha/kernel/systbls.S
+++ b/arch/alpha/kernel/systbls.S
@@ -12,7 +12,7 @@
 sys_call_table:
        .quad alpha_ni_syscall                  /* 0 */
        .quad sys_exit
-        .quad sys_fork
+        .quad alpha_fork
        .quad sys_read
        .quad sys_write
        .quad alpha_ni_syscall                  /* 5 */
@@ -76,7 +76,7 @@ sys_call_table:
        .quad sys_getpgrp
        .quad sys_getpagesize
        .quad alpha_ni_syscall                  /* 65 */
-        .quad sys_vfork
+        .quad alpha_vfork
        .quad sys_newstat
        .quad sys_newlstat
        .quad alpha_ni_syscall
@@ -330,7 +330,7 @@ sys_call_table:
        .quad sys_ni_syscall                    /* 309: old get_kernel_syms */
        .quad sys_syslog                        /* 310 */
        .quad sys_reboot
-        .quad sys_clone
+        .quad alpha_clone
        .quad sys_uselib
        .quad sys_mlock
        .quad sys_munlock                       /* 315 */
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index d7d7c2fc5388..08330d9e6a9c 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -57,6 +57,7 @@ config ARM
        select SYS_SUPPORTS_APM_EMULATION
        select HAVE_MOD_ARCH_SPECIFIC if ARM_UNWIND
        select MODULES_USE_ELF_REL
+        select CLONE_BACKWARDS
        help
          The ARM series is a line of low-power-consumption RISC chip designs
          licensed by ARM Ltd and targeted at embedded applications and
diff --git a/arch/arm/include/asm/signal.h b/arch/arm/include/asm/signal.h
index 5a7963dbd3fb..9a0ea6ab988f 100644
--- a/arch/arm/include/asm/signal.h
+++ b/arch/arm/include/asm/signal.h
@@ -35,5 +35,4 @@ struct k_sigaction {
 };
 #include <asm/sigcontext.h>
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif
diff --git a/arch/arm/include/asm/unistd.h b/arch/arm/include/asm/unistd.h
index 8f60b6e6bd41..7cd13cc62624 100644
--- a/arch/arm/include/asm/unistd.h
+++ b/arch/arm/include/asm/unistd.h
@@ -42,6 +42,9 @@
 #define __ARCH_WANT_SYS_SOCKETCALL
 #endif
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index 831cd38c8d99..5935b6a02e6e 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -11,7 +11,7 @@
 */
 /* 0 */         CALL(sys_restart_syscall)
                CALL(sys_exit)
-                CALL(sys_fork_wrapper)
+                CALL(sys_fork)
                CALL(sys_read)
                CALL(sys_write)
 /* 5 */         CALL(sys_open)
@@ -129,7 +129,7 @@
                CALL(OBSOLETE(ABI(sys_ipc, sys_oabi_ipc)))
                CALL(sys_fsync)
                CALL(sys_sigreturn_wrapper)
-/* 120 */       CALL(sys_clone_wrapper)
+/* 120 */       CALL(sys_clone)
                CALL(sys_setdomainname)
                CALL(sys_newuname)
                CALL(sys_ni_syscall)            /* modify_ldt */
@@ -199,7 +199,7 @@
                CALL(sys_sendfile)
                CALL(sys_ni_syscall)            /* getpmsg */
                CALL(sys_ni_syscall)            /* putpmsg */
-/* 190 */       CALL(sys_vfork_wrapper)
+/* 190 */       CALL(sys_vfork)
                CALL(sys_getrlimit)
                CALL(sys_mmap2)
                CALL(ABI(sys_truncate64, sys_oabi_truncate64))
diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index 804153c0a9cf..a6c301e90a3b 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -502,22 +502,6 @@ sys_syscall:
                b       sys_ni_syscall
 ENDPROC(sys_syscall)
-sys_fork_wrapper:
-                add     r0, sp, #S_OFF
-                b       sys_fork
-ENDPROC(sys_fork_wrapper)
-sys_vfork_wrapper:
-                add     r0, sp, #S_OFF
-                b       sys_vfork
-ENDPROC(sys_vfork_wrapper)
-sys_clone_wrapper:
-                add     ip, sp, #S_OFF
-                str     ip, [sp, #4]
-                b       sys_clone
-ENDPROC(sys_clone_wrapper)
 sys_sigreturn_wrapper:
                add     r0, sp, #S_OFF
                mov     why, #0         @ prevent syscall restart handling
diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c
index 44bc0b327e2b..c6dec5fc20aa 100644
--- a/arch/arm/kernel/process.c
+++ b/arch/arm/kernel/process.c
@@ -376,17 +376,18 @@ asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
 int
 copy_thread(unsigned long clone_flags, unsigned long stack_start,
-            unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
+            unsigned long stk_sz, struct task_struct *p)
 {
        struct thread_info *thread = task_thread_info(p);
        struct pt_regs *childregs = task_pt_regs(p);
        memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
-        if (likely(regs)) {
+        if (likely(!(p->flags & PF_KTHREAD))) {
-                *childregs = *regs;
+                *childregs = *current_pt_regs();
                childregs->ARM_r0 = 0;
-                childregs->ARM_sp = stack_start;
+                if (stack_start)
+                        childregs->ARM_sp = stack_start;
        } else {
                memset(childregs, 0, sizeof(struct pt_regs));
                thread->cpu_context.r4 = stk_sz;
@@ -399,7 +400,7 @@ copy_thread(unsigned long clone_flags, unsigned long stack_start,
        clear_ptrace_hw_breakpoint(p);
        if (clone_flags & CLONE_SETTLS)
-                thread->tp_value = regs->ARM_r3;
+                thread->tp_value = childregs->ARM_r3;
        thread_notify(THREAD_NOTIFY_COPY, thread);
diff --git a/arch/arm/kernel/sys_arm.c b/arch/arm/kernel/sys_arm.c
index c2a898aa57aa..3151f5623d0e 100644
--- a/arch/arm/kernel/sys_arm.c
+++ b/arch/arm/kernel/sys_arm.c
@@ -28,37 +28,6 @@
 #include <linux/uaccess.h>
 #include <linux/slab.h>
-/* Fork a new task - this creates a new program thread.
- * This is called indirectly via a small wrapper
- */
-asmlinkage int sys_fork(struct pt_regs *regs)
-{
-#ifdef CONFIG_MMU
-        return do_fork(SIGCHLD, regs->ARM_sp, regs, 0, NULL, NULL);
-#else
-        /* can not support in nommu mode */
-        return(-EINVAL);
-#endif
-}
-/* Clone a task - this clones the calling program thread.
- * This is called indirectly via a small wrapper
- */
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         int __user *parent_tidptr, int tls_val,
-                         int __user *child_tidptr, struct pt_regs *regs)
-{
-        if (!newsp)
-                newsp = regs->ARM_sp;
-        return do_fork(clone_flags, newsp, regs, 0, parent_tidptr, child_tidptr);
-}
-asmlinkage int sys_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->ARM_sp, regs, 0, NULL, NULL);
-}
 /*
 * Since loff_t is a 64 bit type we avoid a lot of ABI hassle
 * with a different argument ordering.
diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index 2adf340b8589..f9ccff915918 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -33,6 +33,7 @@ config ARM64
        select RTC_LIB
        select SPARSE_IRQ
        select SYSCTL_EXCEPTION_TRACE
+        select CLONE_BACKWARDS
        help
          ARM 64-bit (AArch64) Linux support.
diff --git a/arch/arm64/include/asm/syscalls.h b/arch/arm64/include/asm/syscalls.h
index a1b00cd6f786..20d63b290665 100644
--- a/arch/arm64/include/asm/syscalls.h
+++ b/arch/arm64/include/asm/syscalls.h
@@ -27,12 +27,6 @@ asmlinkage long sys_rt_sigreturn_wrapper(void);
 asmlinkage long sys_sigaltstack_wrapper(const stack_t __user *uss,
                                        stack_t __user *uoss);
-/*
- * AArch64 sys_clone implementation has a different prototype than the generic
- * one (additional TLS value argument).
- */
-#define sys_clone       sys_clone
 #include <asm-generic/syscalls.h>
 #endif  /* __ASM_SYSCALLS_H */
diff --git a/arch/arm64/include/asm/unistd.h b/arch/arm64/include/asm/unistd.h
index 43064a8bd99e..d69aeea6da1e 100644
--- a/arch/arm64/include/asm/unistd.h
+++ b/arch/arm64/include/asm/unistd.h
@@ -24,6 +24,9 @@
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_COMPAT_SYS_SENDFILE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
 #endif
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
 #include <uapi/asm/unistd.h>
diff --git a/arch/arm64/include/asm/unistd32.h b/arch/arm64/include/asm/unistd32.h
index 50104e8ce55d..58432625fdb3 100644
--- a/arch/arm64/include/asm/unistd32.h
+++ b/arch/arm64/include/asm/unistd32.h
@@ -23,7 +23,7 @@
 __SYSCALL(0,   sys_restart_syscall)
 __SYSCALL(1,   sys_exit)
-__SYSCALL(2,   compat_sys_fork)
+__SYSCALL(2,   sys_fork)
 __SYSCALL(3,   sys_read)
 __SYSCALL(4,   sys_write)
 __SYSCALL(5,   compat_sys_open)
@@ -211,7 +211,7 @@ __SYSCALL(186, compat_sys_sigaltstack_wrapper)
 __SYSCALL(187, compat_sys_sendfile)
 __SYSCALL(188, sys_ni_syscall)                  /* 188 reserved */
 __SYSCALL(189, sys_ni_syscall)                  /* 189 reserved */
-__SYSCALL(190, compat_sys_vfork)
+__SYSCALL(190, sys_vfork)
 __SYSCALL(191, compat_sys_getrlimit)            /* SuS compliant getrlimit */
 __SYSCALL(192, sys_mmap_pgoff)
 __SYSCALL(193, compat_sys_truncate64_wrapper)
diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c
index 8a5f3341861e..cb0956bc96ed 100644
--- a/arch/arm64/kernel/process.c
+++ b/arch/arm64/kernel/process.c
@@ -234,16 +234,15 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 asmlinkage void ret_from_fork(void) asm("ret_from_fork");
 int copy_thread(unsigned long clone_flags, unsigned long stack_start,
-                unsigned long stk_sz, struct task_struct *p,
+                unsigned long stk_sz, struct task_struct *p)
-                struct pt_regs *regs)
 {
        struct pt_regs *childregs = task_pt_regs(p);
        unsigned long tls = p->thread.tp_value;
        memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));
-        if (likely(regs)) {
+        if (likely(!(p->flags & PF_KTHREAD))) {
-                *childregs = *regs;
+                *childregs = *current_pt_regs();
                childregs->regs[0] = 0;
                if (is_compat_thread(task_thread_info(p))) {
                        if (stack_start)
@@ -266,7 +265,7 @@ int copy_thread(unsigned long clone_flags, unsigned long stack_start,
                 * for the new thread.
                 */
                if (clone_flags & CLONE_SETTLS)
-                        tls = regs->regs[3];
+                        tls = childregs->regs[3];
        } else {
                memset(childregs, 0, sizeof(struct pt_regs));
                childregs->pstate = PSR_MODE_EL1h;
diff --git a/arch/arm64/kernel/sys.c b/arch/arm64/kernel/sys.c
index 4364df85050e..8292a9b090f8 100644
--- a/arch/arm64/kernel/sys.c
+++ b/arch/arm64/kernel/sys.c
@@ -26,17 +26,6 @@
 #include <linux/slab.h>
 #include <linux/syscalls.h>
-/*
- * Clone a task - this clones the calling program thread.
- */
-asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
-                          int __user *parent_tidptr, unsigned long tls_val,
-                          int __user *child_tidptr)
-{
-        return do_fork(clone_flags, newsp, current_pt_regs(), 0,
-                        parent_tidptr, child_tidptr);
-}
 asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
                         unsigned long prot, unsigned long flags,
                         unsigned long fd, off_t off)
diff --git a/arch/arm64/kernel/sys_compat.c b/arch/arm64/kernel/sys_compat.c
index 6fabc1912da0..f7b05edf8ce3 100644
--- a/arch/arm64/kernel/sys_compat.c
+++ b/arch/arm64/kernel/sys_compat.c
@@ -28,17 +28,6 @@
 #include <asm/cacheflush.h>
 #include <asm/unistd32.h>
-asmlinkage int compat_sys_fork(void)
-{
-        return do_fork(SIGCHLD, 0, current_pt_regs(), 0, NULL, NULL);
-}
-asmlinkage int compat_sys_vfork(void)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
-                       current_pt_regs(), 0, NULL, NULL);
-}
 asmlinkage int compat_sys_sched_rr_get_interval(compat_pid_t pid,
                                                struct compat_timespec __user *interval)
 {
diff --git a/arch/avr32/Kconfig b/arch/avr32/Kconfig
index c2bbc9a72222..202d71a15be1 100644
--- a/arch/avr32/Kconfig
+++ b/arch/avr32/Kconfig
@@ -17,6 +17,8 @@ config AVR32
        select GENERIC_CLOCKEVENTS
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        help
          AVR32 is a high-performance 32-bit RISC microprocessor core,
          designed for cost-sensitive embedded applications, with particular
diff --git a/arch/avr32/include/asm/processor.h b/arch/avr32/include/asm/processor.h
index 87d8baccc60e..48d71c5c898a 100644
--- a/arch/avr32/include/asm/processor.h
+++ b/arch/avr32/include/asm/processor.h
@@ -142,9 +142,6 @@ struct task_struct;
 /* Free all resources held by a thread */
 extern void release_thread(struct task_struct *);
-/* Create a kernel thread without removing it from tasklists */
-extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 /* Return saved PC of a blocked thread */
 #define thread_saved_pc(tsk)    ((tsk)->thread.cpu_context.pc)
diff --git a/arch/avr32/include/asm/signal.h b/arch/avr32/include/asm/signal.h
index 4d502fd6bad3..9326d182e9e5 100644
--- a/arch/avr32/include/asm/signal.h
+++ b/arch/avr32/include/asm/signal.h
@@ -37,6 +37,4 @@ struct k_sigaction {
 #include <asm/sigcontext.h>
 #undef __HAVE_ARCH_SIG_BITOPS
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif
diff --git a/arch/avr32/include/asm/unistd.h b/arch/avr32/include/asm/unistd.h
index 157b4bd3d5e5..f05a9804e8e2 100644
--- a/arch/avr32/include/asm/unistd.h
+++ b/arch/avr32/include/asm/unistd.h
@@ -39,6 +39,10 @@
 #define __ARCH_WANT_SYS_GETPGRP
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/avr32/kernel/Makefile b/arch/avr32/kernel/Makefile
index 9e2c465ef3a6..119a2e41defe 100644
--- a/arch/avr32/kernel/Makefile
+++ b/arch/avr32/kernel/Makefile
@@ -7,7 +7,7 @@ extra-y				:= head.o vmlinux.lds
 obj-$(CONFIG_SUBARCH_AVR32B)    += entry-avr32b.o
 obj-y                           += syscall_table.o syscall-stubs.o irq.o
 obj-y                           += setup.o traps.o ocd.o ptrace.o
-obj-y                           += signal.o sys_avr32.o process.o time.o
+obj-y                           += signal.o process.o time.o
 obj-y                           += switch_to.o cpu.o
 obj-$(CONFIG_MODULES)           += module.o avr32_ksyms.o
 obj-$(CONFIG_KPROBES)           += kprobes.o
diff --git a/arch/avr32/kernel/entry-avr32b.S b/arch/avr32/kernel/entry-avr32b.S
index df2884181313..9899d3cc6f03 100644
--- a/arch/avr32/kernel/entry-avr32b.S
+++ b/arch/avr32/kernel/entry-avr32b.S
@@ -251,13 +251,15 @@ syscall_badsys:
        .global ret_from_fork
 ret_from_fork:
        call   schedule_tail
+        mov     r12, 0
+        rjmp    syscall_return
-        /* check for syscall tracing */
+        .global ret_from_kernel_thread
-        get_thread_info r0
+ret_from_kernel_thread:
-        ld.w    r1, r0[TI_flags]
+        call   schedule_tail
-        andl    r1, _TIF_ALLWORK_MASK, COH
+        mov     r12, r0
-        brne    syscall_exit_work
+        mov     lr, r2  /* syscall_return */
-        rjmp    syscall_exit_cont
+        mov     pc, r1
 syscall_trace_enter:
        pushm   r8-r12
diff --git a/arch/avr32/kernel/process.c b/arch/avr32/kernel/process.c
index 1bb0a8abd79b..fd78f58ea79a 100644
--- a/arch/avr32/kernel/process.c
+++ b/arch/avr32/kernel/process.c
@@ -69,44 +69,6 @@ void machine_restart(char *cmd)
 }
 /*
- * PC is actually discarded when returning from a system call -- the
- * return address must be stored in LR. This function will make sure
- * LR points to do_exit before starting the thread.
- *
- * Also, when returning from fork(), r12 is 0, so we must copy the
- * argument as well.
- *
- *  r0 : The argument to the main thread function
- *  r1 : The address of do_exit
- *  r2 : The address of the main thread function
- */
-asmlinkage extern void kernel_thread_helper(void);
-__asm__("       .type   kernel_thread_helper, @function\n"
-        "kernel_thread_helper:\n"
-        "       mov     r12, r0\n"
-        "       mov     lr, r2\n"
-        "       mov     pc, r1\n"
-        "       .size   kernel_thread_helper, . - kernel_thread_helper");
-int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.r0 = (unsigned long)arg;
-        regs.r1 = (unsigned long)fn;
-        regs.r2 = (unsigned long)do_exit;
-        regs.lr = (unsigned long)kernel_thread_helper;
-        regs.pc = (unsigned long)kernel_thread_helper;
-        regs.sr = MODE_SUPERVISOR;
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
-                       0, &regs, 0, NULL, NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
-/*
 * Free current thread data structures etc
 */
 void exit_thread(void)
@@ -332,26 +294,32 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 }
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
+asmlinkage void syscall_return(void);
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg,
-                struct task_struct *p, struct pt_regs *regs)
+                struct task_struct *p)
 {
-        struct pt_regs *childregs;
+        struct pt_regs *childregs = task_pt_regs(p);
-        childregs = ((struct pt_regs *)(THREAD_SIZE + (unsigned long)task_stack_page(p))) - 1;
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        *childregs = *regs;
+                memset(childregs, 0, sizeof(struct pt_regs));
+                p->thread.cpu_context.r0 = arg;
-        if (user_mode(regs))
+                p->thread.cpu_context.r1 = usp; /* fn */
-                childregs->sp = usp;
+                p->thread.cpu_context.r2 = syscall_return;
-        else
+                p->thread.cpu_context.pc = (unsigned long)ret_from_kernel_thread;
-                childregs->sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;
+                childregs->sr = MODE_SUPERVISOR;
+        } else {
-        childregs->r12 = 0; /* Set return value for child */
+                *childregs = *current_pt_regs();
+                if (usp)
+                        childregs->sp = usp;
+                childregs->r12 = 0; /* Set return value for child */
+                p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
+        }
        p->thread.cpu_context.sr = MODE_SUPERVISOR | SR_GM;
        p->thread.cpu_context.ksp = (unsigned long)childregs;
-        p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
        clear_tsk_thread_flag(p, TIF_DEBUG);
        if ((clone_flags & CLONE_PTRACE) && test_thread_flag(TIF_DEBUG))
@@ -360,49 +328,6 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        return 0;
 }
-/* r12-r8 are dummy parameters to force the compiler to use the stack */
-asmlinkage int sys_fork(struct pt_regs *regs)
-{
-        return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
-}
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                void __user *parent_tidptr, void __user *child_tidptr,
-                struct pt_regs *regs)
-{
-        if (!newsp)
-                newsp = regs->sp;
-        return do_fork(clone_flags, newsp, regs, 0, parent_tidptr,
-                        child_tidptr);
-}
-asmlinkage int sys_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs,
-                       0, NULL, NULL);
-}
-asmlinkage int sys_execve(const char __user *ufilename,
-                          const char __user *const __user *uargv,
-                          const char __user *const __user *uenvp,
-                          struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(ufilename);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, uargv, uenvp, regs);
-        putname(filename);
-out:
-        return error;
-}
 /*
 * This function is supposed to answer the question "who called
 * schedule()?"
diff --git a/arch/avr32/kernel/sys_avr32.c b/arch/avr32/kernel/sys_avr32.c
deleted file mode 100644
index 62635a09ae3e..000000000000
--- a/arch/avr32/kernel/sys_avr32.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2004-2006 Atmel Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-#include <linux/unistd.h>
-int kernel_execve(const char *file,
-                  const char *const *argv,
-                  const char *const *envp)
-{
-        register long scno asm("r8") = __NR_execve;
-        register long sc1 asm("r12") = (long)file;
-        register long sc2 asm("r11") = (long)argv;
-        register long sc3 asm("r10") = (long)envp;
-        asm volatile("scall"
-                     : "=r"(sc1)
-                     : "r"(scno), "0"(sc1), "r"(sc2), "r"(sc3)
-                     : "cc", "memory");
-        return sc1;
-}
diff --git a/arch/avr32/kernel/syscall-stubs.S b/arch/avr32/kernel/syscall-stubs.S
index 0447a3e2ba64..275aab9731fd 100644
--- a/arch/avr32/kernel/syscall-stubs.S
+++ b/arch/avr32/kernel/syscall-stubs.S
@@ -32,30 +32,6 @@ __sys_rt_sigreturn:
        mov     r12, sp
        rjmp    sys_rt_sigreturn
-        .global __sys_fork
-        .type   __sys_fork,@function
-__sys_fork:
-        mov     r12, sp
-        rjmp    sys_fork
-        .global __sys_clone
-        .type   __sys_clone,@function
-__sys_clone:
-        mov     r8, sp
-        rjmp    sys_clone
-        .global __sys_vfork
-        .type   __sys_vfork,@function
-__sys_vfork:
-        mov     r12, sp
-        rjmp    sys_vfork
-        .global __sys_execve
-        .type   __sys_execve,@function
-__sys_execve:
-        mov     r9, sp
-        rjmp    sys_execve
        .global __sys_mmap2
        .type   __sys_mmap2,@function
 __sys_mmap2:
diff --git a/arch/avr32/kernel/syscall_table.S b/arch/avr32/kernel/syscall_table.S
index 6eba53530d1c..f27bb878da6b 100644
--- a/arch/avr32/kernel/syscall_table.S
+++ b/arch/avr32/kernel/syscall_table.S
@@ -15,7 +15,7 @@
 sys_call_table:
        .long   sys_restart_syscall
        .long   sys_exit
-        .long   __sys_fork
+        .long   sys_fork
        .long   sys_read
        .long   sys_write
        .long   sys_open                /* 5 */
@@ -24,7 +24,7 @@ sys_call_table:
        .long   sys_creat
        .long   sys_link
        .long   sys_unlink              /* 10 */
-        .long   __sys_execve
+        .long   sys_execve
        .long   sys_chdir
        .long   sys_time
        .long   sys_mknod
@@ -57,7 +57,7 @@ sys_call_table:
        .long   sys_dup
        .long   sys_pipe
        .long   sys_times
-        .long   __sys_clone
+        .long   sys_clone
        .long   sys_brk                 /* 45 */
        .long   sys_setgid
        .long   sys_getgid
@@ -127,7 +127,7 @@ sys_call_table:
        .long   sys_newuname
        .long   sys_adjtimex
        .long   sys_mprotect
-        .long   __sys_vfork
+        .long   sys_vfork
        .long   sys_init_module         /* 115 */
        .long   sys_delete_module
        .long   sys_quotactl
diff --git a/arch/blackfin/Kconfig b/arch/blackfin/Kconfig
index b6f3ad5441c5..ab9ff4075f4d 100644
--- a/arch/blackfin/Kconfig
+++ b/arch/blackfin/Kconfig
@@ -45,6 +45,8 @@ config BLACKFIN
        select ARCH_USES_GETTIMEOFFSET if !GENERIC_CLOCKEVENTS
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 config GENERIC_CSUM
        def_bool y
diff --git a/arch/blackfin/include/asm/processor.h b/arch/blackfin/include/asm/processor.h
index 4ef7cfe43ceb..d0e72e9475a6 100644
--- a/arch/blackfin/include/asm/processor.h
+++ b/arch/blackfin/include/asm/processor.h
@@ -75,8 +75,6 @@ static inline void release_thread(struct task_struct *dead_task)
 {
 }
-extern int kernel_thread(int (*fn) (void *), void *arg, unsigned long flags);
 /*
 * Free current thread data structures etc..
 */
diff --git a/arch/blackfin/include/asm/unistd.h b/arch/blackfin/include/asm/unistd.h
index 5b2a0748d7d3..460514a1a4e1 100644
--- a/arch/blackfin/include/asm/unistd.h
+++ b/arch/blackfin/include/asm/unistd.h
@@ -446,6 +446,8 @@
 #define __ARCH_WANT_SYS_NICE
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_VFORK
 /*
 * "Conditional" syscalls
diff --git a/arch/blackfin/kernel/entry.S b/arch/blackfin/kernel/entry.S
index f33792cc1a0d..4071265fc4fe 100644
--- a/arch/blackfin/kernel/entry.S
+++ b/arch/blackfin/kernel/entry.S
@@ -46,53 +46,14 @@ ENTRY(_ret_from_fork)
        SP += -12;
        pseudo_long_call _schedule_tail, p5;
        SP += 12;
-        r0 = [sp + PT_IPEND];
+        p1 = [sp++];
-        cc = bittst(r0,1);
+        r0 = [sp++];
-        if cc jump .Lin_kernel;
+        cc = p1 == 0;
+        if cc jump .Lfork;
+        sp += -12;
+        call (p1);
+        sp += 12;
+.Lfork:
        RESTORE_CONTEXT
        rti;
-.Lin_kernel:
-        bitclr(r0,1);
-        [sp + PT_IPEND] = r0;
-        /* do a 'fake' RTI by jumping to [RETI]
-         * to avoid clearing supervisor mode in child
-         */
-        r0 = [sp + PT_PC];
-        [sp + PT_P0] = r0;
-        RESTORE_ALL_SYS
-        jump (p0);
 ENDPROC(_ret_from_fork)
-ENTRY(_sys_vfork)
-        r0 = sp;
-        r0 += 24;
-        [--sp] = rets;
-        SP += -12;
-        pseudo_long_call _bfin_vfork, p2;
-        SP += 12;
-        rets = [sp++];
-        rts;
-ENDPROC(_sys_vfork)
-ENTRY(_sys_clone)
-        r0 = sp;
-        r0 += 24;
-        [--sp] = rets;
-        SP += -12;
-        pseudo_long_call _bfin_clone, p2;
-        SP += 12;
-        rets = [sp++];
-        rts;
-ENDPROC(_sys_clone)
-ENTRY(_sys_rt_sigreturn)
-        r0 = sp;
-        r0 += 24;
-        [--sp] = rets;
-        SP += -12;
-        pseudo_long_call _do_rt_sigreturn, p2;
-        SP += 12;
-        rets = [sp++];
-        rts;
-ENDPROC(_sys_rt_sigreturn)
diff --git a/arch/blackfin/kernel/process.c b/arch/blackfin/kernel/process.c
index bb1cc721fcf7..3e16ad9b0a99 100644
--- a/arch/blackfin/kernel/process.c
+++ b/arch/blackfin/kernel/process.c
@@ -102,40 +102,6 @@ void cpu_idle(void)
 }
 /*
- * This gets run with P1 containing the
- * function to call, and R1 containing
- * the "args".  Note P0 is clobbered on the way here.
- */
-void kernel_thread_helper(void);
-__asm__(".section .text\n"
-        ".align 4\n"
-        "_kernel_thread_helper:\n\t"
-        "\tsp += -12;\n\t"
-        "\tr0 = r1;\n\t" "\tcall (p1);\n\t" "\tcall _do_exit;\n" ".previous");
-/*
- * Create a kernel thread.
- */
-pid_t kernel_thread(int (*fn) (void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.r1 = (unsigned long)arg;
-        regs.p1 = (unsigned long)fn;
-        regs.pc = (unsigned long)kernel_thread_helper;
-        regs.orig_p0 = -1;
-        /* Set bit 2 to tell ret_from_fork we should be returning to kernel
-           mode.  */
-        regs.ipend = 0x8002;
-        __asm__ __volatile__("%0 = syscfg;":"=da"(regs.syscfg):);
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL,
-                       NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
-/*
 * Do necessary setup to start up a newly executed thread.
 *
 * pass the data segment into user programs if it exists,
@@ -161,70 +127,48 @@ void flush_thread(void)
 {
 }
-asmlinkage int bfin_vfork(struct pt_regs *regs)
+asmlinkage int bfin_clone(unsigned long clone_flags, unsigned long newsp)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL,
-                       NULL);
-}
-asmlinkage int bfin_clone(struct pt_regs *regs)
 {
-        unsigned long clone_flags;
-        unsigned long newsp;
 #ifdef __ARCH_SYNC_CORE_DCACHE
        if (current->nr_cpus_allowed == num_possible_cpus())
                set_cpus_allowed_ptr(current, cpumask_of(smp_processor_id()));
 #endif
+        if (newsp)
-        /* syscall2 puts clone_flags in r0 and usp in r1 */
-        clone_flags = regs->r0;
-        newsp = regs->r1;
-        if (!newsp)
-                newsp = rdusp();
-        else
                newsp -= 12;
-        return do_fork(clone_flags, newsp, regs, 0, NULL, NULL);
+        return do_fork(clone_flags, newsp, 0, NULL, NULL);
 }
 int
 copy_thread(unsigned long clone_flags,
            unsigned long usp, unsigned long topstk,
-            struct task_struct *p, struct pt_regs *regs)
+            struct task_struct *p)
 {
        struct pt_regs *childregs;
+        unsigned long *v;
        childregs = (struct pt_regs *) (task_stack_page(p) + THREAD_SIZE) - 1;
-        *childregs = *regs;
+        v = ((unsigned long *)childregs) - 2;
-        childregs->r0 = 0;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
+                v[0] = usp;
+                v[1] = topstk;
+                childregs->orig_p0 = -1;
+                childregs->ipend = 0x8000;
+                __asm__ __volatile__("%0 = syscfg;":"=da"(childregs->syscfg):);
+                p->thread.usp = 0;
+        } else {
+                *childregs = *current_pt_regs();
+                childregs->r0 = 0;
+                p->thread.usp = usp ? : rdusp();
+                v[0] = v[1] = 0;
+        }
-        p->thread.usp = usp;
+        p->thread.ksp = (unsigned long)v;
-        p->thread.ksp = (unsigned long)childregs;
        p->thread.pc = (unsigned long)ret_from_fork;
        return 0;
 }
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char __user *name,
-                          const char __user *const __user *argv,
-                          const char __user *const __user *envp)
-{
-        int error;
-        struct filename *filename;
-        struct pt_regs *regs = (struct pt_regs *)((&name) + 6);
-        filename = getname(name);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                return error;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-        return error;
-}
 unsigned long get_wchan(struct task_struct *p)
 {
        unsigned long fp, pc;
diff --git a/arch/blackfin/kernel/signal.c b/arch/blackfin/kernel/signal.c
index 6ed20a1a4af9..84b4be05840c 100644
--- a/arch/blackfin/kernel/signal.c
+++ b/arch/blackfin/kernel/signal.c
@@ -82,9 +82,9 @@ rt_restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *p
        return err;
 }
-asmlinkage int do_rt_sigreturn(unsigned long __unused)
+asmlinkage int sys_rt_sigreturn(void)
 {
-        struct pt_regs *regs = (struct pt_regs *)__unused;
+        struct pt_regs *regs = current_pt_regs();
        unsigned long usp = rdusp();
        struct rt_sigframe *frame = (struct rt_sigframe *)(usp);
        sigset_t set;
diff --git a/arch/blackfin/mach-common/entry.S b/arch/blackfin/mach-common/entry.S
index 1c3d2c5bb0bb..86b5a095c5a1 100644
--- a/arch/blackfin/mach-common/entry.S
+++ b/arch/blackfin/mach-common/entry.S
@@ -530,61 +530,6 @@ ENTRY(_trap) /* Exception: 4th entry into system event table(supervisor mode)*/
        jump .Lsyscall_really_exit;
 ENDPROC(_trap)
-ENTRY(_kernel_execve)
-        link SIZEOF_PTREGS;
-        p0 = sp;
-        r3 = SIZEOF_PTREGS / 4;
-        r4 = 0(x);
-.Lclear_regs:
-        [p0++] = r4;
-        r3 += -1;
-        cc = r3 == 0;
-        if !cc jump .Lclear_regs (bp);
-        p0 = sp;
-        sp += -16;
-        [sp + 12] = p0;
-        pseudo_long_call _do_execve, p5;
-        SP += 16;
-        cc = r0 == 0;
-        if ! cc jump .Lexecve_failed;
-        /* Success.  Copy our temporary pt_regs to the top of the kernel
-         * stack and do a normal exception return.
-         */
-        r1 = sp;
-        r0 = (-KERNEL_STACK_SIZE) (x);
-        r1 = r1 & r0;
-        p2 = r1;
-        p3 = [p2];
-        r0 = KERNEL_STACK_SIZE - 4 (z);
-        p1 = r0;
-        p1 = p1 + p2;
-        p0 = fp;
-        r4 = [p0--];
-        r3 = SIZEOF_PTREGS / 4;
-.Lcopy_regs:
-        r4 = [p0--];
-        [p1--] = r4;
-        r3 += -1;
-        cc = r3 == 0;
-        if ! cc jump .Lcopy_regs (bp);
-        r0 = (KERNEL_STACK_SIZE - SIZEOF_PTREGS) (z);
-        p1 = r0;
-        p1 = p1 + p2;
-        sp = p1;
-        r0 = syscfg;
-        [SP + PT_SYSCFG] = r0;
-        [p3 + (TASK_THREAD + THREAD_KSP)] = sp;
-        RESTORE_CONTEXT;
-        rti;
-.Lexecve_failed:
-        unlink;
-        rts;
-ENDPROC(_kernel_execve)
 ENTRY(_system_call)
        /* Store IPEND */
        p2.l = lo(IPEND);
@@ -1486,7 +1431,7 @@ ENTRY(_sys_call_table)
        .long _sys_ni_syscall   /* old sys_ipc */
        .long _sys_fsync
        .long _sys_ni_syscall   /* old sys_sigreturn */
-        .long _sys_clone                /* 120 */
+        .long _bfin_clone               /* 120 */
        .long _sys_setdomainname
        .long _sys_newuname
        .long _sys_ni_syscall   /* old sys_modify_ldt */
diff --git a/arch/c6x/Kconfig b/arch/c6x/Kconfig
index aee1b569ee6e..66eab3703c75 100644
--- a/arch/c6x/Kconfig
+++ b/arch/c6x/Kconfig
@@ -18,6 +18,7 @@ config C6X
        select OF_EARLY_FLATTREE
        select GENERIC_CLOCKEVENTS
        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        select MODULES_USE_ELF_RELA
 config MMU
diff --git a/arch/c6x/include/asm/syscalls.h b/arch/c6x/include/asm/syscalls.h
index e7b8991dc07c..df3d05feb153 100644
--- a/arch/c6x/include/asm/syscalls.h
+++ b/arch/c6x/include/asm/syscalls.h
@@ -41,10 +41,6 @@ extern long sys_fallocate_c6x(int fd, int mode,
                              u32 len_lo, u32 len_hi);
 extern int sys_cache_sync(unsigned long s, unsigned long e);
-struct pt_regs;
-extern asmlinkage long sys_c6x_clone(struct pt_regs *regs);
 #include <asm-generic/syscalls.h>
 #endif /* __ASM_C6X_SYSCALLS_H */
diff --git a/arch/c6x/include/uapi/asm/unistd.h b/arch/c6x/include/uapi/asm/unistd.h
index 4ff747d12dad..f3987a8703d9 100644
--- a/arch/c6x/include/uapi/asm/unistd.h
+++ b/arch/c6x/include/uapi/asm/unistd.h
@@ -14,8 +14,8 @@
 *   more details.
 */
-#define __ARCH_WANT_KERNEL_EXECVE
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
 /* Use the standard ABI for syscalls. */
 #include <asm-generic/unistd.h>
diff --git a/arch/c6x/kernel/entry.S b/arch/c6x/kernel/entry.S
index 0ed6157dd256..5239057de4c4 100644
--- a/arch/c6x/kernel/entry.S
+++ b/arch/c6x/kernel/entry.S
@@ -415,19 +415,9 @@ ENTRY(ret_from_kernel_thread)
 0:
        B       .S2     B10                /* call fn */
        LDW     .D2T1   *+SP(REGS_A1+8),A4 /* get arg */
-        MVKL    .S2     sys_exit,B11
+        ADDKPC  .S2     ret_from_fork_2,B3,3
-        MVKH    .S2     sys_exit,B11
-        ADDKPC  .S2     0f,B3,1
-0:
-        BNOP    .S2     B11,5   /* jump to sys_exit */
 ENDPROC(ret_from_kernel_thread)
-ENTRY(ret_from_kernel_execve)
-        GET_THREAD_INFO A12
-        BNOP    .S2     syscall_exit,4
-        ADD     .D2X    A4,-8,SP
-ENDPROC(ret_from_kernel_execve)
        ;;
        ;; These are the interrupt handlers, responsible for calling c6x_do_IRQ()
        ;;
@@ -624,18 +614,6 @@ ENDPROC(sys_sigaltstack)
        ;; Special system calls
        ;; return address is in B3
        ;;
-ENTRY(sys_clone)
-        ADD     .D1X    SP,8,A4
-#ifdef CONFIG_C6X_BIG_KERNEL
- ||     MVKL    .S1     sys_c6x_clone,A0
-        MVKH    .S1     sys_c6x_clone,A0
-        BNOP    .S2X    A0,5
-#else
- ||     B       .S2     sys_c6x_clone
-        NOP     5
-#endif
-ENDPROC(sys_clone)
 ENTRY(sys_rt_sigreturn)
        ADD     .D1X    SP,8,A4
 #ifdef CONFIG_C6X_BIG_KERNEL
diff --git a/arch/c6x/kernel/process.c b/arch/c6x/kernel/process.c
index 2770d9a9a84e..6434df476f77 100644
--- a/arch/c6x/kernel/process.c
+++ b/arch/c6x/kernel/process.c
@@ -112,22 +112,6 @@ void exit_thread(void)
 {
 }
-SYSCALL_DEFINE1(c6x_clone, struct pt_regs *, regs)
-{
-        unsigned long clone_flags;
-        unsigned long newsp;
-        /* syscall puts clone_flags in A4 and usp in B4 */
-        clone_flags = regs->orig_a4;
-        if (regs->b4)
-                newsp = regs->b4;
-        else
-                newsp = regs->sp;
-        return do_fork(clone_flags, newsp, regs, 0, (int __user *)regs->a6,
-                       (int __user *)regs->b6);
-}
 /*
 * Do necessary setup to start up a newly executed thread.
 */
@@ -155,13 +139,13 @@ void start_thread(struct pt_regs *regs, unsigned int pc, unsigned long usp)
 */
 int copy_thread(unsigned long clone_flags, unsigned long usp,
                unsigned long ustk_size,
-                struct task_struct *p, struct pt_regs *regs)
+                struct task_struct *p)
 {
        struct pt_regs *childregs;
        childregs = task_pt_regs(p);
-        if (!regs) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* case of  __kernel_thread: we return to supervisor space */
                memset(childregs, 0, sizeof(struct pt_regs));
                childregs->sp = (unsigned long)(childregs + 1);
@@ -170,8 +154,9 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
                childregs->a1 = ustk_size;      /* argument */
        } else {
                /* Otherwise use the given stack */
-                *childregs = *regs;
+                *childregs = *current_pt_regs();
-                childregs->sp = usp;
+                if (usp)
+                        childregs->sp = usp;
                p->thread.pc = (unsigned long) ret_from_fork;
        }
diff --git a/arch/cris/Kconfig b/arch/cris/Kconfig
index a67244473a39..0cac6a49f230 100644
--- a/arch/cris/Kconfig
+++ b/arch/cris/Kconfig
@@ -49,6 +49,9 @@ config CRIS
        select GENERIC_SMP_IDLE_THREAD if ETRAX_ARCH_V32
        select GENERIC_CMOS_UPDATE
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
+        select CLONE_BACKWARDS2
 config HZ
        int
diff --git a/arch/cris/arch-v10/kernel/entry.S b/arch/cris/arch-v10/kernel/entry.S
index 592fbe9dfb62..897bba67bf7a 100644
--- a/arch/cris/arch-v10/kernel/entry.S
+++ b/arch/cris/arch-v10/kernel/entry.S
@@ -35,6 +35,7 @@
        .globl system_call
        .globl ret_from_intr
        .globl ret_from_fork
+        .globl ret_from_kernel_thread
        .globl resume
        .globl multiple_interrupt
        .globl hwbreakpoint
@@ -81,7 +82,14 @@ ret_from_fork:
        jsr schedule_tail
        ba  ret_from_sys_call
        nop
-                
+ret_from_kernel_thread:
+        jsr schedule_tail
+        move.d  $r2, $r10       ; argument is here
+        jsr     $r1             ; call the payload
+        moveq   0, $r9          ; no syscall restarts, TYVM...
+        ba  ret_from_sys_call
 ret_from_intr:
        ;; check for resched if preemptive kernel or if we're going back to user-mode 
        ;; this test matches the user_regs(regs) macro
@@ -586,13 +594,6 @@ _ugdb_handle_breakpoint:
        ba      do_sigtrap              ; SIGTRAP the offending process. 
        pop     $dccr                   ; Restore dccr in delay slot.
-        .global kernel_execve
-kernel_execve:
-        move.d __NR_execve, $r9
-        break 13
-        ret
-        nop
        .data
 hw_bp_trigs:
diff --git a/arch/cris/arch-v10/kernel/process.c b/arch/cris/arch-v10/kernel/process.c
index 15ac7150371f..b1018750cffb 100644
--- a/arch/cris/arch-v10/kernel/process.c
+++ b/arch/cris/arch-v10/kernel/process.c
@@ -17,6 +17,7 @@
 #include <arch/svinto.h>
 #include <linux/init.h>
 #include <arch/system.h>
+#include <linux/ptrace.h>
 #ifdef CONFIG_ETRAX_GPIO
 void etrax_gpio_wake_up_check(void); /* drivers/gpio.c */
@@ -81,31 +82,6 @@ unsigned long thread_saved_pc(struct task_struct *t)
        return task_pt_regs(t)->irp;
 }
-static void kernel_thread_helper(void* dummy, int (*fn)(void *), void * arg)
-{
-  fn(arg);
-  do_exit(-1); /* Should never be called, return bad exit value */
-}
-/*
- * Create a kernel thread
- */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        /* Don't use r10 since that is set to 0 in copy_thread */
-        regs.r11 = (unsigned long)fn;
-        regs.r12 = (unsigned long)arg;
-        regs.irp = (unsigned long)kernel_thread_helper;
-        regs.dccr = 1 << I_DCCR_BITNR;
-        /* Ok, create the new process.. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
-}
 /* setup the child's kernel stack with a pt_regs and switch_stack on it.
 * it will be un-nested during _resume and _ret_from_sys_call when the
 * new thread is scheduled.
@@ -115,29 +91,34 @@ int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 *
 */
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs * childregs;
+        struct pt_regs *childregs = task_pt_regs(p);
-        struct switch_stack *swstack;
+        struct switch_stack *swstack = ((struct switch_stack *)childregs) - 1;
        
        /* put the pt_regs structure at the end of the new kernel stack page and fix it up
         * remember that the task_struct doubles as the kernel stack for the task
         */
-        childregs = task_pt_regs(p);
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        
+                memset(swstack, 0,
-        *childregs = *regs;  /* struct copy of pt_regs */
+                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
-        
+                swstack->r1 = usp;
-        p->set_child_tid = p->clear_child_tid = NULL;
+                swstack->r2 = arg;
+                childregs->dccr = 1 << I_DCCR_BITNR;
+                swstack->return_ip = (unsigned long) ret_from_kernel_thread;
+                p->thread.ksp = (unsigned long) swstack;
+                p->thread.usp = 0;
+                return 0;
+        }
+        *childregs = *current_pt_regs();  /* struct copy of pt_regs */
        childregs->r10 = 0;  /* child returns 0 after a fork/clone */
-        
-        /* put the switch stack right below the pt_regs */
-        swstack = ((struct switch_stack *)childregs) - 1;
+        /* put the switch stack right below the pt_regs */
        swstack->r9 = 0; /* parameter to ret_from_sys_call, 0 == dont restart the syscall */
@@ -147,7 +128,7 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        
        /* fix the user-mode stackpointer */
-        p->thread.usp = usp;    
+        p->thread.usp = usp ?: rdusp();
        /* and the kernel-mode one */
@@ -161,70 +142,6 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        return 0;
 }
-/* 
- * Be aware of the "magic" 7th argument in the four system-calls below.
- * They need the latest stackframe, which is put as the 7th argument by
- * entry.S. The previous arguments are dummies or actually used, but need
- * to be defined to reach the 7th argument.
- *
- * N.B.: Another method to get the stackframe is to use current_regs(). But
- * it returns the latest stack-frame stacked when going from _user mode_ and
- * some of these (at least sys_clone) are called from kernel-mode sometimes
- * (for example during kernel_thread, above) and thus cannot use it. Thus,
- * to be sure not to get any surprises, we use the method for the other calls
- * as well.
- */
-asmlinkage int sys_fork(long r10, long r11, long r12, long r13, long mof, long srp,
-                        struct pt_regs *regs)
-{
-        return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-}
-/* if newusp is 0, we just grab the old usp */
-/* FIXME: Is parent_tid/child_tid really third/fourth argument? Update lib? */
-asmlinkage int sys_clone(unsigned long newusp, unsigned long flags,
-                         int* parent_tid, int* child_tid, long mof, long srp,
-                         struct pt_regs *regs)
-{
-        if (!newusp)
-                newusp = rdusp();
-        return do_fork(flags, newusp, regs, 0, parent_tid, child_tid);
-}
-/* vfork is a system call in i386 because of register-pressure - maybe
- * we can remove it and handle it in libc but we put it here until then.
- */
-asmlinkage int sys_vfork(long r10, long r11, long r12, long r13, long mof, long srp,
-                         struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-}
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char *fname,
-                          const char *const *argv,
-                          const char *const *envp,
-                          long r13, long mof, long srp, 
-                          struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(fname);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
- out:
-        return error;
-}
 unsigned long get_wchan(struct task_struct *p)
 {
 #if 0
diff --git a/arch/cris/arch-v32/kernel/entry.S b/arch/cris/arch-v32/kernel/entry.S
index c3ea4694fbaf..faa644111feb 100644
--- a/arch/cris/arch-v32/kernel/entry.S
+++ b/arch/cris/arch-v32/kernel/entry.S
@@ -31,6 +31,7 @@
        .globl system_call
        .globl ret_from_intr
        .globl ret_from_fork
+        .globl ret_from_kernel_thread
        .globl resume
        .globl multiple_interrupt
        .globl nmi_interrupt
@@ -84,6 +85,18 @@ ret_from_fork:
        nop
        .size   ret_from_fork, . - ret_from_fork
+        .type   ret_from_kernel_thread,@function
+ret_from_kernel_thread:
+        jsr schedule_tail
+        nop
+        move.d  $r2, $r10
+        jsr     $r1
+        nop
+        moveq   0, $r9                  ; no syscall restarts, TYVM...
+        ba  ret_from_sys_call
+        nop
+        .size   ret_from_kernel_thread, . - ret_from_kernel_thread
        .type   ret_from_intr,@function
 ret_from_intr:
        ;; Check for resched if preemptive kernel, or if we're going back to
@@ -531,15 +544,6 @@ _ugdb_handle_exception:
        ba      do_sigtrap              ; SIGTRAP the offending process.
        move.d  [$sp+], $r0             ; Restore R0 in delay slot.
-        .global kernel_execve
-        .type   kernel_execve,@function
-kernel_execve:
-        move.d __NR_execve, $r9
-        break 13
-        ret
-        nop
-        .size   kernel_execve, . - kernel_execve
        .data
        .section .rodata,"a"
diff --git a/arch/cris/arch-v32/kernel/process.c b/arch/cris/arch-v32/kernel/process.c
index 4e9992246359..2b23ef0e4452 100644
--- a/arch/cris/arch-v32/kernel/process.c
+++ b/arch/cris/arch-v32/kernel/process.c
@@ -16,6 +16,7 @@
 #include <hwregs/reg_map.h>
 #include <hwregs/timer_defs.h>
 #include <hwregs/intr_vect_defs.h>
+#include <linux/ptrace.h>
 extern void stop_watchdog(void);
@@ -94,31 +95,6 @@ unsigned long thread_saved_pc(struct task_struct *t)
        return task_pt_regs(t)->erp;
 }
-static void
-kernel_thread_helper(void* dummy, int (*fn)(void *), void * arg)
-{
-        fn(arg);
-        do_exit(-1); /* Should never be called, return bad exit value. */
-}
-/* Create a kernel thread. */
-int
-kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        /* Don't use r10 since that is set to 0 in copy_thread. */
-        regs.r11 = (unsigned long) fn;
-        regs.r12 = (unsigned long) arg;
-        regs.erp = (unsigned long) kernel_thread_helper;
-        regs.ccs = 1 << (I_CCS_BITNR + CCS_SHIFT);
-        /* Create the new process. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
-}
 /*
 * Setup the child's kernel stack with a pt_regs and call switch_stack() on it.
 * It will be unnested during _resume and _ret_from_sys_call when the new thread
@@ -129,34 +105,42 @@ kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 */
 extern asmlinkage void ret_from_fork(void);
+extern asmlinkage void ret_from_kernel_thread(void);
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-        unsigned long unused,
+        unsigned long arg, struct task_struct *p)
-        struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs *childregs;
+        struct pt_regs *childregs = task_pt_regs(p);
-        struct switch_stack *swstack;
+        struct switch_stack *swstack = ((struct switch_stack *) childregs) - 1;
        /*
         * Put the pt_regs structure at the end of the new kernel stack page and
         * fix it up. Note: the task_struct doubles as the kernel stack for the
         * task.
         */
-        childregs = task_pt_regs(p);
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        *childregs = *regs;     /* Struct copy of pt_regs. */
+                memset(swstack, 0,
-        p->set_child_tid = p->clear_child_tid = NULL;
+                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
+                swstack->r1 = usp;
+                swstack->r2 = arg;
+                childregs->ccs = 1 << (I_CCS_BITNR + CCS_SHIFT);
+                swstack->return_ip = (unsigned long) ret_from_kernel_thread;
+                p->thread.ksp = (unsigned long) swstack;
+                p->thread.usp = 0;
+                return 0;
+        }
+        *childregs = *current_pt_regs();        /* Struct copy of pt_regs. */
        childregs->r10 = 0;     /* Child returns 0 after a fork/clone. */
        /* Set a new TLS ?
         * The TLS is in $mof because it is the 5th argument to sys_clone.
         */
        if (p->mm && (clone_flags & CLONE_SETTLS)) {
-                task_thread_info(p)->tls = regs->mof;
+                task_thread_info(p)->tls = childregs->mof;
        }
        /* Put the switch stack right below the pt_regs. */
-        swstack = ((struct switch_stack *) childregs) - 1;
        /* Parameter to ret_from_sys_call. 0 is don't restart the syscall. */
        swstack->r9 = 0;
@@ -168,76 +152,12 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
        swstack->return_ip = (unsigned long) ret_from_fork;
        /* Fix the user-mode and kernel-mode stackpointer. */
-        p->thread.usp = usp;
+        p->thread.usp = usp ?: rdusp();
        p->thread.ksp = (unsigned long) swstack;
        return 0;
 }
-/*
- * Be aware of the "magic" 7th argument in the four system-calls below.
- * They need the latest stackframe, which is put as the 7th argument by
- * entry.S. The previous arguments are dummies or actually used, but need
- * to be defined to reach the 7th argument.
- *
- * N.B.: Another method to get the stackframe is to use current_regs(). But
- * it returns the latest stack-frame stacked when going from _user mode_ and
- * some of these (at least sys_clone) are called from kernel-mode sometimes
- * (for example during kernel_thread, above) and thus cannot use it. Thus,
- * to be sure not to get any surprises, we use the method for the other calls
- * as well.
- */
-asmlinkage int
-sys_fork(long r10, long r11, long r12, long r13, long mof, long srp,
-        struct pt_regs *regs)
-{
-        return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-}
-/* FIXME: Is parent_tid/child_tid really third/fourth argument? Update lib? */
-asmlinkage int
-sys_clone(unsigned long newusp, unsigned long flags, int *parent_tid, int *child_tid,
-        unsigned long tls, long srp, struct pt_regs *regs)
-{
-        if (!newusp)
-                newusp = rdusp();
-        return do_fork(flags, newusp, regs, 0, parent_tid, child_tid);
-}
-/*
- * vfork is a system call in i386 because of register-pressure - maybe
- * we can remove it and handle it in libc but we put it here until then.
- */
-asmlinkage int
-sys_vfork(long r10, long r11, long r12, long r13, long mof, long srp,
-        struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-}
-/* sys_execve() executes a new program. */
-asmlinkage int
-sys_execve(const char *fname,
-           const char *const *argv,
-           const char *const *envp, long r13, long mof, long srp,
-           struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(fname);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
- out:
-        return error;
-}
 unsigned long
 get_wchan(struct task_struct *p)
 {
diff --git a/arch/cris/include/asm/processor.h b/arch/cris/include/asm/processor.h
index ef4e1bc3efc8..675823f70c0f 100644
--- a/arch/cris/include/asm/processor.h
+++ b/arch/cris/include/asm/processor.h
@@ -49,8 +49,6 @@ struct task_struct;
 #define task_pt_regs(task) user_regs(task_thread_info(task))
 #define current_regs() task_pt_regs(current)
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 unsigned long get_wchan(struct task_struct *p);
 #define KSTK_ESP(tsk)   ((tsk) == current ? rdusp() : (tsk)->thread.usp)
diff --git a/arch/cris/include/asm/signal.h b/arch/cris/include/asm/signal.h
index ea6af9aad76c..72dbbf59dfae 100644
--- a/arch/cris/include/asm/signal.h
+++ b/arch/cris/include/asm/signal.h
@@ -152,12 +152,6 @@ typedef struct sigaltstack {
 #ifdef __KERNEL__
 #include <asm/sigcontext.h>
-/* here we could define asm-optimized sigaddset, sigdelset etc. operations. 
- * if we don't, generic ones are used from linux/signal.h
- */
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* __KERNEL__ */
 #endif
diff --git a/arch/cris/include/asm/unistd.h b/arch/cris/include/asm/unistd.h
index 51873a446f87..f27b542e0ebc 100644
--- a/arch/cris/include/asm/unistd.h
+++ b/arch/cris/include/asm/unistd.h
@@ -371,6 +371,10 @@
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/cris/kernel/crisksyms.c b/arch/cris/kernel/crisksyms.c
index 7ac000f6a888..5868cee20ebd 100644
--- a/arch/cris/kernel/crisksyms.c
+++ b/arch/cris/kernel/crisksyms.c
@@ -30,7 +30,6 @@ extern void __negdi2(void);
 extern void iounmap(volatile void * __iomem);
 /* Platform dependent support */
-EXPORT_SYMBOL(kernel_thread);
 EXPORT_SYMBOL(get_cmos_time);
 EXPORT_SYMBOL(loops_per_usec);
diff --git a/arch/frv/include/asm/unistd.h b/arch/frv/include/asm/unistd.h
index 2358634cacca..1807d8ea8cb5 100644
--- a/arch/frv/include/asm/unistd.h
+++ b/arch/frv/include/asm/unistd.h
@@ -30,6 +30,9 @@
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/frv/kernel/process.c b/arch/frv/kernel/process.c
index 7e33215f1d8f..23916b2a12a2 100644
--- a/arch/frv/kernel/process.c
+++ b/arch/frv/kernel/process.c
@@ -139,42 +139,12 @@ inline unsigned long user_stack(const struct pt_regs *regs)
        return user_mode(regs) ? regs->sp : 0;
 }
-asmlinkage int sys_fork(void)
-{
-#ifndef CONFIG_MMU
-        /* fork almost works, enough to trick you into looking elsewhere:-( */
-        return -EINVAL;
-#else
-        return do_fork(SIGCHLD, user_stack(__frame), __frame, 0, NULL, NULL);
-#endif
-}
-asmlinkage int sys_vfork(void)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, user_stack(__frame), __frame, 0,
-                       NULL, NULL);
-}
-/*****************************************************************************/
-/*
- * clone a process
- * - tlsptr is retrieved by copy_thread()
- */
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         int __user *parent_tidptr, int __user *child_tidptr,
-                         int __user *tlsptr)
-{
-        if (!newsp)
-                newsp = user_stack(__frame);
-        return do_fork(clone_flags, newsp, __frame, 0, parent_tidptr, child_tidptr);
-} /* end sys_clone() */
 /*
 * set up the kernel stack and exception frames for a new process
 */
 int copy_thread(unsigned long clone_flags,
                unsigned long usp, unsigned long arg,
-                struct task_struct *p, struct pt_regs *regs)
+                struct task_struct *p)
 {
        struct pt_regs *childregs;
@@ -182,9 +152,7 @@ int copy_thread(unsigned long clone_flags,
                (task_stack_page(p) + THREAD_SIZE - FRV_FRAME0_SIZE);
        /* set up the userspace frame (the only place that the USP is stored) */
-        *childregs = *__kernel_frame0_ptr;
+        *childregs = *current_pt_regs();
-        p->set_child_tid = p->clear_child_tid = NULL;
        p->thread.frame  = childregs;
        p->thread.curr   = p;
@@ -193,18 +161,15 @@ int copy_thread(unsigned long clone_flags,
        p->thread.lr     = 0;
        p->thread.frame0 = childregs;
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                childregs->gr9 = usp; /* function */
                childregs->gr8 = arg;
                p->thread.pc = (unsigned long) ret_from_kernel_thread;
                save_user_regs(p->thread.user);
                return 0;
        }
+        if (usp)
-        /* set up the userspace frame (the only place that the USP is stored) */
+                childregs->sp = usp;
-        *childregs = *regs;
-        childregs->sp           = usp;
        childregs->next_frame   = NULL;
        p->thread.pc = (unsigned long) ret_from_fork;
diff --git a/arch/h8300/Kconfig b/arch/h8300/Kconfig
index 98fabd10e95f..04bef4d25b4a 100644
--- a/arch/h8300/Kconfig
+++ b/arch/h8300/Kconfig
@@ -8,6 +8,8 @@ config H8300
        select GENERIC_IRQ_SHOW
        select GENERIC_CPU_DEVICES
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 config SYMBOL_PREFIX
        string
diff --git a/arch/h8300/include/asm/processor.h b/arch/h8300/include/asm/processor.h
index 4c9f6f87b617..4b0ca49bb463 100644
--- a/arch/h8300/include/asm/processor.h
+++ b/arch/h8300/include/asm/processor.h
@@ -107,8 +107,6 @@ static inline void release_thread(struct task_struct *dead_task)
 {
 }
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 /*
 * Free current thread data structures etc..
 */
diff --git a/arch/h8300/include/asm/ptrace.h b/arch/h8300/include/asm/ptrace.h
index d09c440bdba7..7468589a128b 100644
--- a/arch/h8300/include/asm/ptrace.h
+++ b/arch/h8300/include/asm/ptrace.h
@@ -60,6 +60,9 @@ struct pt_regs {
 #define user_mode(regs) (!((regs)->ccr & PS_S))
 #define instruction_pointer(regs) ((regs)->pc)
 #define profile_pc(regs) instruction_pointer(regs)
+#define current_pt_regs() ((struct pt_regs *) \
+        (THREAD_SIZE + (unsigned long)current_thread_info()) - 1)
+#define signal_pt_regs() ((struct pt_regs *)current->thread.esp0)
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
 #endif /* _H8300_PTRACE_H */
diff --git a/arch/h8300/include/asm/signal.h b/arch/h8300/include/asm/signal.h
index fd8b66e40dca..c43c0a7d2c2e 100644
--- a/arch/h8300/include/asm/signal.h
+++ b/arch/h8300/include/asm/signal.h
@@ -154,8 +154,6 @@ typedef struct sigaltstack {
 #include <asm/sigcontext.h>
 #undef __HAVE_ARCH_SIG_BITOPS
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* __KERNEL__ */
 #endif /* _H8300_SIGNAL_H */
diff --git a/arch/h8300/include/asm/unistd.h b/arch/h8300/include/asm/unistd.h
index 5cd882801d79..c2c2f5c7d6bf 100644
--- a/arch/h8300/include/asm/unistd.h
+++ b/arch/h8300/include/asm/unistd.h
@@ -356,6 +356,10 @@
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/h8300/kernel/entry.S b/arch/h8300/kernel/entry.S
index ca7431690300..617a6878787f 100644
--- a/arch/h8300/kernel/entry.S
+++ b/arch/h8300/kernel/entry.S
@@ -158,6 +158,7 @@ INTERRUPTS = 128
 .globl SYMBOL_NAME(system_call)
 .globl SYMBOL_NAME(ret_from_exception)
 .globl SYMBOL_NAME(ret_from_fork)
+.globl SYMBOL_NAME(ret_from_kernel_thread)
 .globl SYMBOL_NAME(ret_from_interrupt)
 .globl SYMBOL_NAME(interrupt_redirect_table)
 .globl SYMBOL_NAME(sw_ksp),SYMBOL_NAME(sw_usp)
@@ -330,6 +331,14 @@ SYMBOL_NAME_LABEL(ret_from_fork)
        jsr     @SYMBOL_NAME(schedule_tail)
        jmp     @SYMBOL_NAME(ret_from_exception)
+SYMBOL_NAME_LABEL(ret_from_kernel_thread)
+        mov.l   er2,er0
+        jsr     @SYMBOL_NAME(schedule_tail)
+        mov.l   @(LER4:16,sp),er0
+        mov.l   @(LER5:16,sp),er1
+        jsr     @er1
+        jmp     @SYMBOL_NAME(ret_from_exception)
 SYMBOL_NAME_LABEL(resume)
        /*
         * Beware - when entering resume, offset of tss is in d1,
diff --git a/arch/h8300/kernel/h8300_ksyms.c b/arch/h8300/kernel/h8300_ksyms.c
index 6866bd9c7fb4..53d7c0e4bd83 100644
--- a/arch/h8300/kernel/h8300_ksyms.c
+++ b/arch/h8300/kernel/h8300_ksyms.c
@@ -33,7 +33,6 @@ EXPORT_SYMBOL(strncmp);
 EXPORT_SYMBOL(ip_fast_csum);
-EXPORT_SYMBOL(kernel_thread);
 EXPORT_SYMBOL(enable_irq);
 EXPORT_SYMBOL(disable_irq);
diff --git a/arch/h8300/kernel/process.c b/arch/h8300/kernel/process.c
index e8dc1393a13a..b609f63f1590 100644
--- a/arch/h8300/kernel/process.c
+++ b/arch/h8300/kernel/process.c
@@ -47,6 +47,7 @@ void (*pm_power_off)(void) = NULL;
 EXPORT_SYMBOL(pm_power_off);
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
 /*
 * The idle loop on an H8/300..
@@ -122,113 +123,34 @@ void show_regs(struct pt_regs * regs)
                printk("\n");
 }
-/*
- * Create a kernel thread
- */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        long retval;
-        long clone_arg;
-        mm_segment_t fs;
-        fs = get_fs();
-        set_fs (KERNEL_DS);
-        clone_arg = flags | CLONE_VM;
-        __asm__("mov.l sp,er3\n\t"
-                "sub.l er2,er2\n\t"
-                "mov.l %2,er1\n\t"
-                "mov.l %1,er0\n\t"
-                "trapa #0\n\t"
-                "cmp.l sp,er3\n\t"
-                "beq 1f\n\t"
-                "mov.l %4,er0\n\t"
-                "mov.l %3,er1\n\t"
-                "jsr @er1\n\t"
-                "mov.l %5,er0\n\t"
-                "trapa #0\n"
-                "1:\n\t"
-                "mov.l er0,%0"
-                :"=r"(retval)
-                :"i"(__NR_clone),"g"(clone_arg),"g"(fn),"g"(arg),"i"(__NR_exit)
-                :"er0","er1","er2","er3");
-        set_fs (fs);
-        return retval;
-}
 void flush_thread(void)
 {
 }
-/*
- * "h8300_fork()".. By the time we get here, the
- * non-volatile registers have also been saved on the
- * stack. We do some ugly pointer stuff here.. (see
- * also copy_thread)
- */
-asmlinkage int h8300_fork(struct pt_regs *regs)
-{
-        return -EINVAL;
-}
-asmlinkage int h8300_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-}
-asmlinkage int h8300_clone(struct pt_regs *regs)
-{
-        unsigned long clone_flags;
-        unsigned long newsp;
-        /* syscall2 puts clone_flags in er1 and usp in er2 */
-        clone_flags = regs->er1;
-        newsp = regs->er2;
-        if (!newsp)
-                newsp  = rdusp();
-        return do_fork(clone_flags, newsp, regs, 0, NULL, NULL);
-}
 int copy_thread(unsigned long clone_flags,
                unsigned long usp, unsigned long topstk,
-                 struct task_struct * p, struct pt_regs * regs)
+                 struct task_struct * p)
 {
        struct pt_regs * childregs;
        childregs = (struct pt_regs *) (THREAD_SIZE + task_stack_page(p)) - 1;
-        *childregs = *regs;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
+                childregs->retpc = (unsigned long) ret_from_kernel_thread;
+                childregs->er4 = topstk; /* arg */
+                childregs->er5 = usp; /* fn */
+                p->thread.ksp = (unsigned long)childregs;
+        }
+        *childregs = *current_pt_regs();
        childregs->retpc = (unsigned long) ret_from_fork;
        childregs->er0 = 0;
+        p->thread.usp = usp ?: rdusp();
-        p->thread.usp = usp;
        p->thread.ksp = (unsigned long)childregs;
        return 0;
 }
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char *name,
-                          const char *const *argv,
-                          const char *const *envp,
-                          int dummy, ...)
-{
-        int error;
-        struct filename *filename;
-        struct pt_regs *regs = (struct pt_regs *) ((unsigned char *)&dummy-4);
-        filename = getname(name);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                return error;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-        return error;
-}
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
        return ((struct pt_regs *)tsk->thread.esp0)->pc;
diff --git a/arch/h8300/kernel/sys_h8300.c b/arch/h8300/kernel/sys_h8300.c
index 4bdc7311784e..bf350cb7f597 100644
--- a/arch/h8300/kernel/sys_h8300.c
+++ b/arch/h8300/kernel/sys_h8300.c
@@ -46,29 +46,3 @@ asmlinkage void syscall_print(void *dummy,...)
               ((regs->pc)&0xffffff)-2,regs->orig_er0,regs->er1,regs->er2,regs->er3,regs->er0);
 }
 #endif
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-asmlinkage
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register long res __asm__("er0");
-        register const char *const *_c __asm__("er3") = envp;
-        register const char *const *_b __asm__("er2") = argv;
-        register const char * _a __asm__("er1") = filename;
-        __asm__ __volatile__ ("mov.l %1,er0\n\t"
-                        "trapa  #0\n\t"
-                        : "=r" (res)
-                        : "g" (__NR_execve),
-                          "g" (_a),
-                          "g" (_b),
-                          "g" (_c)
-                        : "cc", "memory");
-        return res;
-}
diff --git a/arch/h8300/kernel/syscalls.S b/arch/h8300/kernel/syscalls.S
index 9d77e715a2ed..b74dd0ade58d 100644
--- a/arch/h8300/kernel/syscalls.S
+++ b/arch/h8300/kernel/syscalls.S
@@ -340,21 +340,12 @@ SYMBOL_NAME_LABEL(sys_call_table)
        bra     SYMBOL_NAME(syscall_trampoline):8
        .endm
-SYMBOL_NAME_LABEL(sys_clone)    
-        call_sp h8300_clone
-        
 SYMBOL_NAME_LABEL(sys_sigreturn)
        call_sp do_sigreturn
 SYMBOL_NAME_LABEL(sys_rt_sigreturn)
        call_sp do_rt_sigreturn
-SYMBOL_NAME_LABEL(sys_fork)
-        call_sp h8300_fork
-SYMBOL_NAME_LABEL(sys_vfork)
-        call_sp h8300_vfork
 SYMBOL_NAME_LABEL(syscall_trampoline)
        mov.l   sp,er0
        jmp     @er6
diff --git a/arch/hexagon/Kconfig b/arch/hexagon/Kconfig
index 0744f7d7b1fd..e418803b6c8e 100644
--- a/arch/hexagon/Kconfig
+++ b/arch/hexagon/Kconfig
@@ -31,6 +31,8 @@ config HEXAGON
        select GENERIC_CLOCKEVENTS
        select GENERIC_CLOCKEVENTS_BROADCAST
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        ---help---
          Qualcomm Hexagon is a processor architecture designed for high
          performance and low power across a wide variety of applications.
diff --git a/arch/hexagon/include/asm/processor.h b/arch/hexagon/include/asm/processor.h
index a03323ab9d44..6dd5d3706869 100644
--- a/arch/hexagon/include/asm/processor.h
+++ b/arch/hexagon/include/asm/processor.h
@@ -34,7 +34,6 @@
 struct task_struct;
 /*  this is defined in arch/process.c  */
-extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 extern unsigned long thread_saved_pc(struct task_struct *tsk);
 extern void start_thread(struct pt_regs *, unsigned long, unsigned long);
diff --git a/arch/hexagon/include/asm/syscall.h b/arch/hexagon/include/asm/syscall.h
index fb0e9d48faa6..4af9c7b6f13a 100644
--- a/arch/hexagon/include/asm/syscall.h
+++ b/arch/hexagon/include/asm/syscall.h
@@ -25,14 +25,6 @@ typedef long (*syscall_fn)(unsigned long, unsigned long,
        unsigned long, unsigned long,
        unsigned long, unsigned long);
-asmlinkage int sys_execve(char __user *ufilename, char __user * __user *argv,
-                          char __user * __user *envp);
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long parent_tidp, unsigned long child_tidp);
-#define sys_execve      sys_execve
-#define sys_clone       sys_clone
 #include <asm-generic/syscalls.h>
 extern void *sys_call_table[];
diff --git a/arch/hexagon/include/uapi/asm/ptrace.h b/arch/hexagon/include/uapi/asm/ptrace.h
index 8ef784047a74..1ffce0c6ee07 100644
--- a/arch/hexagon/include/uapi/asm/ptrace.h
+++ b/arch/hexagon/include/uapi/asm/ptrace.h
@@ -32,4 +32,8 @@
 extern int regs_query_register_offset(const char *name);
 extern const char *regs_query_register_name(unsigned int offset);
+#define current_pt_regs() \
+        ((struct pt_regs *) \
+         ((unsigned long)current_thread_info() + THREAD_SIZE) - 1)
 #endif
diff --git a/arch/hexagon/include/uapi/asm/unistd.h b/arch/hexagon/include/uapi/asm/unistd.h
index 81312d6a52e6..2af81533bd0f 100644
--- a/arch/hexagon/include/uapi/asm/unistd.h
+++ b/arch/hexagon/include/uapi/asm/unistd.h
@@ -27,5 +27,7 @@
 */
 #define sys_mmap2 sys_mmap_pgoff
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
 #include <asm-generic/unistd.h>
diff --git a/arch/hexagon/kernel/Makefile b/arch/hexagon/kernel/Makefile
index 536aec093e62..6c19501b487c 100644
--- a/arch/hexagon/kernel/Makefile
+++ b/arch/hexagon/kernel/Makefile
@@ -3,8 +3,7 @@ extra-y := head.o vmlinux.lds
 obj-$(CONFIG_SMP) += smp.o topology.o
 obj-y += setup.o irq_cpu.o traps.o syscalltab.o signal.o time.o
-obj-y += process.o syscall.o trampoline.o reset.o ptrace.o
+obj-y += process.o trampoline.o reset.o ptrace.o vdso.o
-obj-y += vdso.o
 obj-$(CONFIG_KGDB)    += kgdb.o
 obj-$(CONFIG_MODULES) += module.o hexagon_ksyms.o
diff --git a/arch/hexagon/kernel/process.c b/arch/hexagon/kernel/process.c
index 9f6d7411b574..06ae9ffcabd5 100644
--- a/arch/hexagon/kernel/process.c
+++ b/arch/hexagon/kernel/process.c
@@ -26,33 +26,6 @@
 #include <linux/slab.h>
 /*
- * Kernel thread creation.  The desired kernel function is "wrapped"
- * in the kernel_thread_helper function, which does cleanup
- * afterwards.
- */
-static void __noreturn kernel_thread_helper(void *arg, int (*fn)(void *))
-{
-        do_exit(fn(arg));
-}
-int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        /*
-         * Yes, we're exploting illicit knowledge of the ABI here.
-         */
-        regs.r00 = (unsigned long) arg;
-        regs.r01 = (unsigned long) fn;
-        pt_set_elr(&regs, (unsigned long)kernel_thread_helper);
-        pt_set_kmode(&regs);
-        return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
-/*
 * Program thread launch.  Often defined as a macro in processor.h,
 * but we're shooting for a small footprint and it's not an inner-loop
 * performance-critical operation.
@@ -114,8 +87,7 @@ unsigned long thread_saved_pc(struct task_struct *tsk)
 * Copy architecture-specific thread state
 */
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused, struct task_struct *p,
+                unsigned long arg, struct task_struct *p)
-                struct pt_regs *regs)
 {
        struct thread_info *ti = task_thread_info(p);
        struct hexagon_switch_stack *ss;
@@ -125,61 +97,51 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) -
                                        sizeof(*childregs));
-        memcpy(childregs, regs, sizeof(*childregs));
        ti->regs = childregs;
        /*
         * Establish kernel stack pointer and initial PC for new thread
+         * Note that unlike the usual situation, we do not copy the
+         * parent's callee-saved here; those are in pt_regs and whatever
+         * we leave here will be overridden on return to userland.
         */
        ss = (struct hexagon_switch_stack *) ((unsigned long) childregs -
                                                    sizeof(*ss));
        ss->lr = (unsigned long)ret_from_fork;
        p->thread.switch_sp = ss;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
+                /* r24 <- fn, r25 <- arg */
+                ss->r2524 = usp | ((u64)arg << 32);
+                pt_set_kmode(childregs);
+                return 0;
+        }
+        memcpy(childregs, current_pt_regs(), sizeof(*childregs));
+        ss->r2524 = 0;
-        /* If User mode thread, set pt_reg stack pointer as per parameter */
+        if (usp)
-        if (user_mode(childregs)) {
                pt_set_rte_sp(childregs, usp);
-                /* Child sees zero return value */
+        /* Child sees zero return value */
-                childregs->r00 = 0;
+        childregs->r00 = 0;
-                /*
+        /*
-                 * The clone syscall has the C signature:
+         * The clone syscall has the C signature:
-                 * int [r0] clone(int flags [r0],
+         * int [r0] clone(int flags [r0],
-                 *           void *child_frame [r1],
+         *           void *child_frame [r1],
-                 *           void *parent_tid [r2],
+         *           void *parent_tid [r2],
-                 *           void *child_tid [r3],
+         *           void *child_tid [r3],
-                 *           void *thread_control_block [r4]);
+         *           void *thread_control_block [r4]);
-                 * ugp is used to provide TLS support.
+         * ugp is used to provide TLS support.
-                 */
+         */
-                if (clone_flags & CLONE_SETTLS)
+        if (clone_flags & CLONE_SETTLS)
-                        childregs->ugp = childregs->r04;
+                childregs->ugp = childregs->r04;
-                /*
-                 * Parent sees new pid -- not necessary, not even possible at
-                 * this point in the fork process
-                 * Might also want to set things like ti->addr_limit
-                 */
-        } else {
-                /*
-                 * If kernel thread, resume stack is kernel stack base.
-                 * Note that this is pointer arithmetic on pt_regs *
-                 */
-                pt_set_rte_sp(childregs, (unsigned long)(childregs + 1));
-                /*
-                 * We need the current thread_info fast path pointer
-                 * set up in pt_regs.  The register to be used is
-                 * parametric for assembler code, but the mechanism
-                 * doesn't drop neatly into C.  Needs to be fixed.
-                 */
-                childregs->THREADINFO_REG = (unsigned long) ti;
-        }
        /*
-         * thread_info pointer is pulled out of task_struct "stack"
+         * Parent sees new pid -- not necessary, not even possible at
-         * field on switch_to.
+         * this point in the fork process
+         * Might also want to set things like ti->addr_limit
         */
-        p->stack = (void *)ti;
        return 0;
 }
diff --git a/arch/hexagon/kernel/signal.c b/arch/hexagon/kernel/signal.c
index 5047b8b879c0..fe0d1373165d 100644
--- a/arch/hexagon/kernel/signal.c
+++ b/arch/hexagon/kernel/signal.c
@@ -249,14 +249,14 @@ void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 */
 asmlinkage int sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 {
-        struct pt_regs *regs = current_thread_info()->regs;
+        struct pt_regs *regs = current_pt_regs();
        return do_sigaltstack(uss, uoss, regs->r29);
 }
 asmlinkage int sys_rt_sigreturn(void)
 {
-        struct pt_regs *regs = current_thread_info()->regs;
+        struct pt_regs *regs = current_pt_regs();
        struct rt_sigframe __user *frame;
        sigset_t blocked;
diff --git a/arch/hexagon/kernel/syscall.c b/arch/hexagon/kernel/syscall.c
deleted file mode 100644
index 319fa6494f58..000000000000
--- a/arch/hexagon/kernel/syscall.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Hexagon system calls
- *
- * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 and
- * only version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-#include <linux/file.h>
-#include <linux/fs.h>
-#include <linux/linkage.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/syscalls.h>
-#include <linux/unistd.h>
-#include <asm/mman.h>
-#include <asm/registers.h>
-/*
- * System calls with architecture-specific wrappers.
- * See signal.c for signal-related system call wrappers.
- */
-asmlinkage int sys_execve(char __user *ufilename,
-                          const char __user *const __user *argv,
-                          const char __user *const __user *envp)
-{
-        struct pt_regs *pregs = current_thread_info()->regs;
-        struct filename *filename;
-        int retval;
-        filename = getname(ufilename);
-        retval = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                return retval;
-        retval = do_execve(filename->name, argv, envp, pregs);
-        putname(filename);
-        return retval;
-}
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long parent_tidp, unsigned long child_tidp)
-{
-        struct pt_regs *pregs = current_thread_info()->regs;
-        if (!newsp)
-                newsp = pregs->SP;
-        return do_fork(clone_flags, newsp, pregs, 0, (int __user *)parent_tidp,
-                       (int __user *)child_tidp);
-}
-/*
- * Do a system call from the kernel, so as to have a proper pt_regs
- * and recycle the sys_execvpe infrustructure.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[], const char *const envp[])
-{
-        register unsigned long __a0 asm("r0") = (unsigned long) filename;
-        register unsigned long __a1 asm("r1") = (unsigned long) argv;
-        register unsigned long __a2 asm("r2") = (unsigned long) envp;
-        int retval;
-        __asm__ volatile(
-                "       R6 = #%4;\n"
-                "       trap0(#1);\n"
-                "       %0 = R0;\n"
-                : "=r" (retval)
-                : "r" (__a0), "r" (__a1), "r" (__a2), "i" (__NR_execve)
-        );
-        return retval;
-}
diff --git a/arch/hexagon/kernel/vm_entry.S b/arch/hexagon/kernel/vm_entry.S
index cd71673ac259..425e50c694f7 100644
--- a/arch/hexagon/kernel/vm_entry.S
+++ b/arch/hexagon/kernel/vm_entry.S
@@ -266,4 +266,8 @@ _K_enter_machcheck:
        .globl ret_from_fork
 ret_from_fork:
        call schedule_tail
+        P0 = cmp.eq(R24, #0);
+        if P0 jump return_from_syscall
+        R0 = R25;
+        callr R24
        jump return_from_syscall
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 3279646120e3..670600468128 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -42,6 +42,8 @@ config IA64
        select GENERIC_TIME_VSYSCALL_OLD
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        default y
        help
          The Itanium Processor Family is Intel's 64-bit successor to
diff --git a/arch/ia64/include/asm/processor.h b/arch/ia64/include/asm/processor.h
index 944152a50912..e0a899a1a8a6 100644
--- a/arch/ia64/include/asm/processor.h
+++ b/arch/ia64/include/asm/processor.h
@@ -340,22 +340,6 @@ struct task_struct;
 */
 #define release_thread(dead_task)
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE 1: Only a kernel-only process (ie the swapper or direct
- * descendants who haven't done an "execve()") should use this: it
- * will work within a system call from a "real" process, but the
- * process memory space will not be free'd until both the parent and
- * the child have exited.
- *
- * NOTE 2: This MUST NOT be an inlined function.  Otherwise, we get
- * into trouble in init/main.c when the child thread returns to
- * do_basic_setup() and the timing is such that free_initmem() has
- * been called already.
- */
-extern pid_t kernel_thread (int (*fn)(void *), void *arg, unsigned long flags);
 /* Get wait channel for task P.  */
 extern unsigned long get_wchan (struct task_struct *p);
diff --git a/arch/ia64/include/asm/signal.h b/arch/ia64/include/asm/signal.h
index aecda5b9eb4e..3a1b20e74c5c 100644
--- a/arch/ia64/include/asm/signal.h
+++ b/arch/ia64/include/asm/signal.h
@@ -38,7 +38,5 @@ struct k_sigaction {
 #  include <asm/sigcontext.h>
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 # endif /* !__ASSEMBLY__ */
 #endif /* _ASM_IA64_SIGNAL_H */
diff --git a/arch/ia64/include/asm/unistd.h b/arch/ia64/include/asm/unistd.h
index 8b3ff2f5b861..1574bca86138 100644
--- a/arch/ia64/include/asm/unistd.h
+++ b/arch/ia64/include/asm/unistd.h
@@ -29,6 +29,7 @@
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
 #if !defined(__ASSEMBLY__) && !defined(ASSEMBLER)
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index 1ccbe12a4d84..e25b784a2b72 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -61,14 +61,13 @@ ENTRY(ia64_execve)
         * Allocate 8 input registers since ptrace() may clobber them
         */
        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
-        alloc loc1=ar.pfs,8,2,4,0
+        alloc loc1=ar.pfs,8,2,3,0
        mov loc0=rp
        .body
        mov out0=in0                    // filename
        ;;                              // stop bit between alloc and call
        mov out1=in1                    // argv
        mov out2=in2                    // envp
-        add out3=16,sp                  // regs
        br.call.sptk.many rp=sys_execve
 .ret0:
        cmp4.ge p6,p7=r8,r0
@@ -76,7 +75,6 @@ ENTRY(ia64_execve)
        sxt4 r8=r8                      // return 64-bit result
        ;;
        stf.spill [sp]=f0
-(p6)    cmp.ne pKStk,pUStk=r0,r0        // a successful execve() lands us in user-mode...
        mov rp=loc0
 (p6)    mov ar.pfs=r0                   // clear ar.pfs on success
 (p7)    br.ret.sptk.many rp
@@ -118,13 +116,12 @@ GLOBAL_ENTRY(sys_clone2)
        mov loc1=r16                            // save ar.pfs across do_fork
        .body
        mov out1=in1
-        mov out3=in2
+        mov out2=in2
        tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out4=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out3=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
        ;;
 (p6)    st8 [r2]=in5                            // store TLS in r16 for copy_thread()
-        mov out5=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out4=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
-        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
        mov out0=in0                            // out0 = clone_flags
        br.call.sptk.many rp=do_fork
 .ret1:  .restore sp
@@ -150,13 +147,12 @@ GLOBAL_ENTRY(sys_clone)
        mov loc1=r16                            // save ar.pfs across do_fork
        .body
        mov out1=in1
-        mov out3=16                             // stacksize (compensates for 16-byte scratch area)
+        mov out2=16                             // stacksize (compensates for 16-byte scratch area)
        tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out4=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out3=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
        ;;
 (p6)    st8 [r2]=in4                            // store TLS in r13 (tp)
-        mov out5=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out4=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
-        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
        mov out0=in0                            // out0 = clone_flags
        br.call.sptk.many rp=do_fork
 .ret2:  .restore sp
@@ -484,19 +480,6 @@ GLOBAL_ENTRY(prefetch_stack)
        br.ret.sptk.many rp
 END(prefetch_stack)
-GLOBAL_ENTRY(kernel_execve)
-        rum psr.ac
-        mov r15=__NR_execve                     // put syscall number in place
-        break __BREAK_SYSCALL
-        br.ret.sptk.many rp
-END(kernel_execve)
-GLOBAL_ENTRY(clone)
-        mov r15=__NR_clone                      // put syscall number in place
-        break __BREAK_SYSCALL
-        br.ret.sptk.many rp
-END(clone)
        /*
         * Invoke a system call, but do some tracing before and after the call.
         * We MUST preserve the current register frame throughout this routine
@@ -600,6 +583,27 @@ GLOBAL_ENTRY(ia64_strace_leave_kernel)
 .ret4:  br.cond.sptk ia64_leave_kernel
 END(ia64_strace_leave_kernel)
+ENTRY(call_payload)
+        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(0)
+        /* call the kernel_thread payload; fn is in r4, arg - in r5 */
+        alloc loc1=ar.pfs,0,3,1,0
+        mov loc0=rp
+        mov loc2=gp
+        mov out0=r5             // arg
+        ld8 r14 = [r4], 8       // fn.address
+        ;;
+        mov b6 = r14
+        ld8 gp = [r4]           // fn.gp
+        ;;
+        br.call.sptk.many rp=b6 // fn(arg)
+.ret12: mov gp=loc2
+        mov rp=loc0
+        mov ar.pfs=loc1
+        /* ... and if it has returned, we are going to userland */
+        cmp.ne pKStk,pUStk=r0,r0
+        br.ret.sptk.many rp
+END(call_payload)
 GLOBAL_ENTRY(ia64_ret_from_clone)
        PT_REGS_UNWIND_INFO(0)
 {       /*
@@ -616,6 +620,7 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
        br.call.sptk.many rp=ia64_invoke_schedule_tail
 }
 .ret8:
+(pKStk) br.call.sptk.many rp=call_payload
        adds r2=TI_FLAGS+IA64_TASK_SIZE,r13
        ;;
        ld4 r2=[r2]
diff --git a/arch/ia64/kernel/head.S b/arch/ia64/kernel/head.S
index 629a250f7c19..4738ff7bd66a 100644
--- a/arch/ia64/kernel/head.S
+++ b/arch/ia64/kernel/head.S
@@ -1093,19 +1093,6 @@ GLOBAL_ENTRY(cycle_to_cputime)
 END(cycle_to_cputime)
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
-GLOBAL_ENTRY(start_kernel_thread)
-        .prologue
-        .save rp, r0                            // this is the end of the call-chain
-        .body
-        alloc r2 = ar.pfs, 0, 0, 2, 0
-        mov out0 = r9
-        mov out1 = r11;;
-        br.call.sptk.many rp = kernel_thread_helper;;
-        mov out0 = r8
-        br.call.sptk.many rp = sys_exit;;
-1:      br.sptk.few 1b                          // not reached
-END(start_kernel_thread)
 #ifdef CONFIG_IA64_BRL_EMU
 /*
diff --git a/arch/ia64/kernel/process.c b/arch/ia64/kernel/process.c
index 35e106f2ed13..31360cbbd5f8 100644
--- a/arch/ia64/kernel/process.c
+++ b/arch/ia64/kernel/process.c
@@ -393,72 +393,24 @@ ia64_load_extra (struct task_struct *task)
 int
 copy_thread(unsigned long clone_flags,
             unsigned long user_stack_base, unsigned long user_stack_size,
-             struct task_struct *p, struct pt_regs *regs)
+             struct task_struct *p)
 {
        extern char ia64_ret_from_clone;
        struct switch_stack *child_stack, *stack;
        unsigned long rbs, child_rbs, rbs_size;
        struct pt_regs *child_ptregs;
+        struct pt_regs *regs = current_pt_regs();
        int retval = 0;
-#ifdef CONFIG_SMP
-        /*
-         * For SMP idle threads, fork_by_hand() calls do_fork with
-         * NULL regs.
-         */
-        if (!regs)
-                return 0;
-#endif
-        stack = ((struct switch_stack *) regs) - 1;
        child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
        child_stack = (struct switch_stack *) child_ptregs - 1;
-        /* copy parent's switch_stack & pt_regs to child: */
-        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
        rbs = (unsigned long) current + IA64_RBS_OFFSET;
        child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
-        rbs_size = stack->ar_bspstore - rbs;
-        /* copy the parent's register backing store to the child: */
-        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
-        if (likely(user_mode(child_ptregs))) {
-                if (clone_flags & CLONE_SETTLS)
-                        child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
-                if (user_stack_base) {
-                        child_ptregs->r12 = user_stack_base + user_stack_size - 16;
-                        child_ptregs->ar_bspstore = user_stack_base;
-                        child_ptregs->ar_rnat = 0;
-                        child_ptregs->loadrs = 0;
-                }
-        } else {
-                /*
-                 * Note: we simply preserve the relative position of
-                 * the stack pointer here.  There is no need to
-                 * allocate a scratch area here, since that will have
-                 * been taken care of by the caller of sys_clone()
-                 * already.
-                 */
-                child_ptregs->r12 = (unsigned long) child_ptregs - 16; /* kernel sp */
-                child_ptregs->r13 = (unsigned long) p;          /* set `current' pointer */
-        }
-        child_stack->ar_bspstore = child_rbs + rbs_size;
-        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
        /* copy parts of thread_struct: */
        p->thread.ksp = (unsigned long) child_stack - 16;
-        /* stop some PSR bits from being inherited.
-         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
-         * therefore we must specify them explicitly here and not include them in
-         * IA64_PSR_BITS_TO_CLEAR.
-         */
-        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
-                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
        /*
         * NOTE: The calling convention considers all floating point
         * registers in the high partition (fph) to be scratch.  Since
@@ -480,8 +432,66 @@ copy_thread(unsigned long clone_flags,
 #       define THREAD_FLAGS_TO_SET      0
        p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
                           | THREAD_FLAGS_TO_SET);
        ia64_drop_fpu(p);       /* don't pick up stale state from a CPU's fph */
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                if (unlikely(!user_stack_base)) {
+                        /* fork_idle() called us */
+                        return 0;
+                }
+                memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
+                child_stack->r4 = user_stack_base;      /* payload */
+                child_stack->r5 = user_stack_size;      /* argument */
+                /*
+                 * Preserve PSR bits, except for bits 32-34 and 37-45,
+                 * which we can't read.
+                 */
+                child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
+                /* mark as valid, empty frame */
+                child_ptregs->cr_ifs = 1UL << 63;
+                child_stack->ar_fpsr = child_ptregs->ar_fpsr
+                        = ia64_getreg(_IA64_REG_AR_FPSR);
+                child_stack->pr = (1 << PRED_KERNEL_STACK);
+                child_stack->ar_bspstore = child_rbs;
+                child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
+                /* stop some PSR bits from being inherited.
+                 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
+                 * therefore we must specify them explicitly here and not include them in
+                 * IA64_PSR_BITS_TO_CLEAR.
+                 */
+                child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
+                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
+                return 0;
+        }
+        stack = ((struct switch_stack *) regs) - 1;
+        /* copy parent's switch_stack & pt_regs to child: */
+        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
+        /* copy the parent's register backing store to the child: */
+        rbs_size = stack->ar_bspstore - rbs;
+        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
+        if (clone_flags & CLONE_SETTLS)
+                child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
+        if (user_stack_base) {
+                child_ptregs->r12 = user_stack_base + user_stack_size - 16;
+                child_ptregs->ar_bspstore = user_stack_base;
+                child_ptregs->ar_rnat = 0;
+                child_ptregs->loadrs = 0;
+        }
+        child_stack->ar_bspstore = child_rbs + rbs_size;
+        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
+        /* stop some PSR bits from being inherited.
+         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
+         * therefore we must specify them explicitly here and not include them in
+         * IA64_PSR_BITS_TO_CLEAR.
+         */
+        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
+                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
 #ifdef CONFIG_PERFMON
        if (current->thread.pfm_context)
                pfm_inherit(p, child_ptregs);
@@ -608,57 +618,6 @@ dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
        return 1;       /* f0-f31 are always valid so we always return 1 */
 }
-long
-sys_execve (const char __user *filename,
-            const char __user *const __user *argv,
-            const char __user *const __user *envp,
-            struct pt_regs *regs)
-{
-        struct filename *fname;
-        int error;
-        fname = getname(filename);
-        error = PTR_ERR(fname);
-        if (IS_ERR(fname))
-                goto out;
-        error = do_execve(fname->name, argv, envp, regs);
-        putname(fname);
-out:
-        return error;
-}
-pid_t
-kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
-{
-        extern void start_kernel_thread (void);
-        unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
-        struct {
-                struct switch_stack sw;
-                struct pt_regs pt;
-        } regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.pt.cr_iip = helper_fptr[0];        /* set entry point (IP) */
-        regs.pt.r1 = helper_fptr[1];            /* set GP */
-        regs.pt.r9 = (unsigned long) fn;        /* 1st argument */
-        regs.pt.r11 = (unsigned long) arg;      /* 2nd argument */
-        /* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read.  */
-        regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
-        regs.pt.cr_ifs = 1UL << 63;             /* mark as valid, empty frame */
-        regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
-        regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
-        regs.sw.pr = (1 << PRED_KERNEL_STACK);
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs.pt, 0, NULL, NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
-/* This gets called from kernel_thread() via ia64_invoke_thread_helper().  */
-int
-kernel_thread_helper (int (*fn)(void *), void *arg)
-{
-        return (*fn)(arg);
-}
 /*
 * Flush thread state.  This is called when a thread does an execve().
 */
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index 963d2db53bfa..6a368cb2043e 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -460,11 +460,6 @@ start_secondary (void *unused)
        return 0;
 }
-struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
-{
-        return NULL;
-}
 static int __cpuinit
 do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
 {
diff --git a/arch/m32r/Kconfig b/arch/m32r/Kconfig
index f807721e19a5..5183f43a2cf7 100644
--- a/arch/m32r/Kconfig
+++ b/arch/m32r/Kconfig
@@ -15,6 +15,8 @@ config M32R
        select GENERIC_ATOMIC64
        select ARCH_USES_GETTIMEOFFSET
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 config SBUS
        bool
diff --git a/arch/m32r/include/asm/processor.h b/arch/m32r/include/asm/processor.h
index da17253b5735..5767367550c6 100644
--- a/arch/m32r/include/asm/processor.h
+++ b/arch/m32r/include/asm/processor.h
@@ -118,11 +118,6 @@ struct mm_struct;
 /* Free all resources held by a thread. */
 extern void release_thread(struct task_struct *);
-/*
- * create a kernel thread without removing it from tasklists
- */
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 /* Copy and release all segment info associated with a VM */
 extern void copy_segments(struct task_struct *p, struct mm_struct * mm);
 extern void release_segments(struct mm_struct * mm);
diff --git a/arch/m32r/include/asm/ptrace.h b/arch/m32r/include/asm/ptrace.h
index 4313aa62b51b..c4432f1fb2cf 100644
--- a/arch/m32r/include/asm/ptrace.h
+++ b/arch/m32r/include/asm/ptrace.h
@@ -139,6 +139,8 @@ extern void withdraw_debug_trap(struct pt_regs *regs);
 #define task_pt_regs(task) \
        ((struct pt_regs *)(task_stack_page(task) + THREAD_SIZE) - 1)
+#define current_pt_regs() ((struct pt_regs *) \
+        ((unsigned long)current_thread_info() + THREAD_SIZE) - 1)
 #endif /* __KERNEL */
diff --git a/arch/m32r/include/asm/signal.h b/arch/m32r/include/asm/signal.h
index ea5f95e4079e..e4d2e2ad5f1e 100644
--- a/arch/m32r/include/asm/signal.h
+++ b/arch/m32r/include/asm/signal.h
@@ -149,10 +149,6 @@ typedef struct sigaltstack {
 #undef __HAVE_ARCH_SIG_BITOPS
-struct pt_regs;
-#define ptrace_signal_deliver(regs, cookie)     do { } while (0)
 #endif /* __KERNEL__ */
 #endif  /* _ASM_M32R_SIGNAL_H */
diff --git a/arch/m32r/include/asm/unistd.h b/arch/m32r/include/asm/unistd.h
index d5e66a480782..d9e7351af2a4 100644
--- a/arch/m32r/include/asm/unistd.h
+++ b/arch/m32r/include/asm/unistd.h
@@ -352,6 +352,10 @@
 #define __ARCH_WANT_SYS_OLDUMOUNT
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
 #define __IGNORE_lchown
 #define __IGNORE_setuid
diff --git a/arch/m32r/kernel/entry.S b/arch/m32r/kernel/entry.S
index 225412bc227e..0c01543f10cd 100644
--- a/arch/m32r/kernel/entry.S
+++ b/arch/m32r/kernel/entry.S
@@ -125,6 +125,15 @@
        and     \reg, sp
        .endm
+ENTRY(ret_from_kernel_thread)
+        pop     r0
+        bl      schedule_tail
+        GET_THREAD_INFO(r8)
+        ld      r0, R0(r8)
+        ld      r1, R1(r8)
+        jl      r1
+        bra     syscall_exit
 ENTRY(ret_from_fork)
        pop     r0
        bl      schedule_tail
diff --git a/arch/m32r/kernel/m32r_ksyms.c b/arch/m32r/kernel/m32r_ksyms.c
index 700570747a90..b727e693c805 100644
--- a/arch/m32r/kernel/m32r_ksyms.c
+++ b/arch/m32r/kernel/m32r_ksyms.c
@@ -21,7 +21,6 @@ EXPORT_SYMBOL(boot_cpu_data);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
-EXPORT_SYMBOL(kernel_thread);
 EXPORT_SYMBOL(strncpy_from_user);
 EXPORT_SYMBOL(__strncpy_from_user);
diff --git a/arch/m32r/kernel/process.c b/arch/m32r/kernel/process.c
index e7366276ef30..765d0f57c787 100644
--- a/arch/m32r/kernel/process.c
+++ b/arch/m32r/kernel/process.c
@@ -165,41 +165,6 @@ void show_regs(struct pt_regs * regs)
 }
 /*
- * Create a kernel thread
- */
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be free'd until both the parent and the child have exited.
- */
-static void kernel_thread_helper(void *nouse, int (*fn)(void *), void *arg)
-{
-        fn(arg);
-        do_exit(-1);
-}
-int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof (regs));
-        regs.r1 = (unsigned long)fn;
-        regs.r2 = (unsigned long)arg;
-        regs.bpc = (unsigned long)kernel_thread_helper;
-        regs.psw = M32R_PSW_BIE;
-        /* Ok, create the new process. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL,
-                NULL);
-}
-/*
 * Free current thread data structures etc..
 */
 void exit_thread(void)
@@ -227,88 +192,31 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 }
 int copy_thread(unsigned long clone_flags, unsigned long spu,
-        unsigned long unused, struct task_struct *tsk, struct pt_regs *regs)
+        unsigned long arg, struct task_struct *tsk)
 {
        struct pt_regs *childregs = task_pt_regs(tsk);
        extern void ret_from_fork(void);
+        extern void ret_from_kernel_thread(void);
-        /* Copy registers */
-        *childregs = *regs;
+        if (unlikely(tsk->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
-        childregs->spu = spu;
+                childregs->psw = M32R_PSW_BIE;
-        childregs->r0 = 0;      /* Child gets zero as return value */
+                childregs->r1 = spu;    /* fn */
-        regs->r0 = tsk->pid;
+                childregs->r0 = arg;
+                tsk->thread.lr = (unsigned long)ret_from_kernel_thread;
+        } else {
+                /* Copy registers */
+                *childregs = *current_pt_regs();
+                if (spu)
+                        childregs->spu = spu;
+                childregs->r0 = 0;      /* Child gets zero as return value */
+                tsk->thread.lr = (unsigned long)ret_from_fork;
+        }
        tsk->thread.sp = (unsigned long)childregs;
-        tsk->thread.lr = (unsigned long)ret_from_fork;
        return 0;
 }
-asmlinkage int sys_fork(unsigned long r0, unsigned long r1, unsigned long r2,
-        unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
-        struct pt_regs regs)
-{
-#ifdef CONFIG_MMU
-        return do_fork(SIGCHLD, regs.spu, &regs, 0, NULL, NULL);
-#else
-        return -EINVAL;
-#endif /* CONFIG_MMU */
-}
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long parent_tidptr,
-                         unsigned long child_tidptr,
-                         unsigned long r4, unsigned long r5, unsigned long r6,
-                         struct pt_regs regs)
-{
-        if (!newsp)
-                newsp = regs.spu;
-        return do_fork(clone_flags, newsp, &regs, 0,
-                       (int __user *)parent_tidptr, (int __user *)child_tidptr);
-}
-/*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
-asmlinkage int sys_vfork(unsigned long r0, unsigned long r1, unsigned long r2,
-        unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
-        struct pt_regs regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.spu, &regs, 0,
-                        NULL, NULL);
-}
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char __user *ufilename,
-                          const char __user *const __user *uargv,
-                          const char __user *const __user *uenvp,
-                          unsigned long r3, unsigned long r4, unsigned long r5,
-                          unsigned long r6, struct pt_regs regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(ufilename);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, uargv, uenvp, &regs);
-        putname(filename);
-out:
-        return error;
-}
 /*
 * These bracket the sleeping functions..
 */
diff --git a/arch/m32r/kernel/sys_m32r.c b/arch/m32r/kernel/sys_m32r.c
index d841fb6cc703..c3fdd632fba7 100644
--- a/arch/m32r/kernel/sys_m32r.c
+++ b/arch/m32r/kernel/sys_m32r.c
@@ -88,24 +88,3 @@ asmlinkage int sys_cachectl(char *addr, int nbytes, int op)
        /* Not implemented yet. */
        return -ENOSYS;
 }
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register long __scno __asm__ ("r7") = __NR_execve;
-        register long __arg3 __asm__ ("r2") = (long)(envp);
-        register long __arg2 __asm__ ("r1") = (long)(argv);
-        register long __res __asm__ ("r0") = (long)(filename);
-        __asm__ __volatile__ (
-                "trap #" SYSCALL_VECTOR "|| nop"
-                : "=r" (__res)
-                : "r" (__scno), "0" (__res), "r" (__arg2),
-                        "r" (__arg3)
-                : "memory");
-        return __res;
-}
diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig
index e7c161433eae..953a7ba5d050 100644
--- a/arch/m68k/Kconfig
+++ b/arch/m68k/Kconfig
@@ -16,6 +16,7 @@ config M68K
        select ARCH_WANT_IPC_PARSE_VERSION
        select ARCH_USES_GETTIMEOFFSET if MMU && !COLDFIRE
        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_REL
        select MODULES_USE_ELF_RELA
diff --git a/arch/m68k/include/asm/signal.h b/arch/m68k/include/asm/signal.h
index 2df26b57c26a..9c8c46b06b0c 100644
--- a/arch/m68k/include/asm/signal.h
+++ b/arch/m68k/include/asm/signal.h
@@ -86,11 +86,9 @@ static inline int sigfindinword(unsigned long word)
 #endif /* !CONFIG_CPU_HAS_NO_BITFIELDS */
-#ifdef __uClinux__
+#ifndef __uClinux__
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
+extern void ptrace_signal_deliver(void);
-#else
+#define ptrace_signal_deliver ptrace_signal_deliver
-struct pt_regs;
-extern void ptrace_signal_deliver(struct pt_regs *regs, void *cookie);
 #endif /* __uClinux__ */
 #endif /* _M68K_SIGNAL_H */
diff --git a/arch/m68k/include/asm/unistd.h b/arch/m68k/include/asm/unistd.h
index 5fc7f7bec1c8..a021d67cdd72 100644
--- a/arch/m68k/include/asm/unistd.h
+++ b/arch/m68k/include/asm/unistd.h
@@ -32,7 +32,8 @@
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_SYS_EXECVE
-#define __ARCH_WANT_KERNEL_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
 /*
 * "Conditional" syscalls
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index 946cb0187751..a78f5649e8de 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -44,34 +44,29 @@
 .globl system_call, buserr, trap, resume
 .globl sys_call_table
-.globl sys_fork, sys_clone, sys_vfork
+.globl __sys_fork, __sys_clone, __sys_vfork
 .globl ret_from_interrupt, bad_interrupt
 .globl auto_irqhandler_fixup
 .globl user_irqvec_fixup
 .text
-ENTRY(sys_fork)
+ENTRY(__sys_fork)
        SAVE_SWITCH_STACK
-        pea     %sp@(SWITCH_STACK_SIZE)
+        jbsr    sys_fork
-        jbsr    m68k_fork
+        lea     %sp@(24),%sp
-        addql   #4,%sp
-        RESTORE_SWITCH_STACK
        rts
-ENTRY(sys_clone)
+ENTRY(__sys_clone)
        SAVE_SWITCH_STACK
        pea     %sp@(SWITCH_STACK_SIZE)
        jbsr    m68k_clone
-        addql   #4,%sp
+        lea     %sp@(28),%sp
-        RESTORE_SWITCH_STACK
        rts
-ENTRY(sys_vfork)
+ENTRY(__sys_vfork)
        SAVE_SWITCH_STACK
-        pea     %sp@(SWITCH_STACK_SIZE)
+        jbsr    sys_vfork
-        jbsr    m68k_vfork
+        lea     %sp@(24),%sp
-        addql   #4,%sp
-        RESTORE_SWITCH_STACK
        rts
 ENTRY(sys_sigreturn)
@@ -115,16 +110,9 @@ ENTRY(ret_from_kernel_thread)
        | a3 contains the kernel thread payload, d7 - its argument
        movel   %d1,%sp@-
        jsr     schedule_tail
-        GET_CURRENT(%d0)
        movel   %d7,(%sp)
        jsr     %a3@
        addql   #4,%sp
-        movel   %d0,(%sp)
-        jra     sys_exit
-ENTRY(ret_from_kernel_execve)
-        movel   4(%sp), %sp
-        GET_CURRENT(%d0)
        jra     ret_from_exception
 #if defined(CONFIG_COLDFIRE) || !defined(CONFIG_MMU)
diff --git a/arch/m68k/kernel/process.c b/arch/m68k/kernel/process.c
index c51bb172e14d..d538694ad208 100644
--- a/arch/m68k/kernel/process.c
+++ b/arch/m68k/kernel/process.c
@@ -136,57 +136,35 @@ void flush_thread(void)
 }
 /*
- * "m68k_fork()".. By the time we get here, the
+ * Why not generic sys_clone, you ask?  m68k passes all arguments on stack.
- * non-volatile registers have also been saved on the
+ * And we need all registers saved, which means a bunch of stuff pushed
- * stack. We do some ugly pointer stuff here.. (see
+ * on top of pt_regs, which means that sys_clone() arguments would be
- * also copy_thread)
+ * buried.  We could, of course, copy them, but it's too costly for no
+ * good reason - generic clone() would have to copy them *again* for
+ * do_fork() anyway.  So in this case it's actually better to pass pt_regs *
+ * and extract arguments for do_fork() from there.  Eventually we might
+ * go for calling do_fork() directly from the wrapper, but only after we
+ * are finished with do_fork() prototype conversion.
 */
-asmlinkage int m68k_fork(struct pt_regs *regs)
-{
-#ifdef CONFIG_MMU
-        return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
-#else
-        return -EINVAL;
-#endif
-}
-asmlinkage int m68k_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0,
-                       NULL, NULL);
-}
 asmlinkage int m68k_clone(struct pt_regs *regs)
 {
-        unsigned long clone_flags;
+        /* regs will be equal to current_pt_regs() */
-        unsigned long newsp;
+        return do_fork(regs->d1, regs->d2, 0,
-        int __user *parent_tidptr, *child_tidptr;
+                       (int __user *)regs->d3, (int __user *)regs->d4);
-        /* syscall2 puts clone_flags in d1 and usp in d2 */
-        clone_flags = regs->d1;
-        newsp = regs->d2;
-        parent_tidptr = (int __user *)regs->d3;
-        child_tidptr = (int __user *)regs->d4;
-        if (!newsp)
-                newsp = rdusp();
-        return do_fork(clone_flags, newsp, regs, 0,
-                       parent_tidptr, child_tidptr);
 }
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                 unsigned long arg,
+                 unsigned long arg, struct task_struct *p)
-                 struct task_struct * p, struct pt_regs * regs)
 {
-        struct pt_regs * childregs;
+        struct fork_frame {
-        struct switch_stack *childstack;
+                struct switch_stack sw;
+                struct pt_regs regs;
+        } *frame;
-        childregs = (struct pt_regs *) (task_stack_page(p) + THREAD_SIZE) - 1;
+        frame = (struct fork_frame *) (task_stack_page(p) + THREAD_SIZE) - 1;
-        childstack = ((struct switch_stack *) childregs) - 1;
-        p->thread.usp = usp;
+        p->thread.ksp = (unsigned long)frame;
-        p->thread.ksp = (unsigned long)childstack;
+        p->thread.esp0 = (unsigned long)&frame->regs;
-        p->thread.esp0 = (unsigned long)childregs;
        /*
         * Must save the current SFC/DFC value, NOT the value when
@@ -194,25 +172,24 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         */
        p->thread.fs = get_fs().seg;
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* kernel thread */
-                memset(childstack, 0,
+                memset(frame, 0, sizeof(struct fork_frame));
-                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
+                frame->regs.sr = PS_S;
-                childregs->sr = PS_S;
+                frame->sw.a3 = usp; /* function */
-                childstack->a3 = usp; /* function */
+                frame->sw.d7 = arg;
-                childstack->d7 = arg;
+                frame->sw.retpc = (unsigned long)ret_from_kernel_thread;
-                childstack->retpc = (unsigned long)ret_from_kernel_thread;
                p->thread.usp = 0;
                return 0;
        }
-        *childregs = *regs;
+        memcpy(frame, container_of(current_pt_regs(), struct fork_frame, regs),
-        childregs->d0 = 0;
+                sizeof(struct fork_frame));
+        frame->regs.d0 = 0;
-        *childstack = ((struct switch_stack *) regs)[-1];
+        frame->sw.retpc = (unsigned long)ret_from_fork;
-        childstack->retpc = (unsigned long)ret_from_fork;
+        p->thread.usp = usp ?: rdusp();
        if (clone_flags & CLONE_SETTLS)
-                task_thread_info(p)->tp_value = regs->d5;
+                task_thread_info(p)->tp_value = frame->regs.d5;
 #ifdef CONFIG_FPU
        if (!FPU_IS_EMU) {
diff --git a/arch/m68k/kernel/signal.c b/arch/m68k/kernel/signal.c
index 710a528b928b..9a396cda3147 100644
--- a/arch/m68k/kernel/signal.c
+++ b/arch/m68k/kernel/signal.c
@@ -108,8 +108,9 @@ int handle_kernel_fault(struct pt_regs *regs)
        return 1;
 }
-void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
+void ptrace_signal_deliver(void)
 {
+        struct pt_regs *regs = signal_pt_regs();
        if (regs->orig_d0 < 0)
                return;
        switch (regs->d0) {
diff --git a/arch/m68k/kernel/syscalltable.S b/arch/m68k/kernel/syscalltable.S
index 4fc2e29b771b..c30da5b3f2db 100644
--- a/arch/m68k/kernel/syscalltable.S
+++ b/arch/m68k/kernel/syscalltable.S
@@ -22,7 +22,7 @@ ALIGN
 ENTRY(sys_call_table)
        .long sys_restart_syscall       /* 0 - old "setup()" system call, used for restarting */
        .long sys_exit
-        .long sys_fork
+        .long __sys_fork
        .long sys_read
        .long sys_write
        .long sys_open                  /* 5 */
@@ -140,7 +140,7 @@ ENTRY(sys_call_table)
        .long sys_ipc
        .long sys_fsync
        .long sys_sigreturn
-        .long sys_clone                 /* 120 */
+        .long __sys_clone               /* 120 */
        .long sys_setdomainname
        .long sys_newuname
        .long sys_cacheflush            /* modify_ldt for i386 */
@@ -210,7 +210,7 @@ ENTRY(sys_call_table)
        .long sys_sendfile
        .long sys_ni_syscall            /* streams1 */
        .long sys_ni_syscall            /* streams2 */
-        .long sys_vfork                 /* 190 */
+        .long __sys_vfork               /* 190 */
        .long sys_getrlimit
        .long sys_mmap2
        .long sys_truncate64
diff --git a/arch/microblaze/Kconfig b/arch/microblaze/Kconfig
index 4cba7439f9de..4bcf89148f3c 100644
--- a/arch/microblaze/Kconfig
+++ b/arch/microblaze/Kconfig
@@ -26,6 +26,9 @@ config MICROBLAZE
        select GENERIC_ATOMIC64
        select GENERIC_CLOCKEVENTS
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
+        select CLONE_BACKWARDS
 config SWAP
        def_bool n
diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild
index 2957fcc71764..eb3a46c096fe 100644
--- a/arch/microblaze/include/asm/Kbuild
+++ b/arch/microblaze/include/asm/Kbuild
@@ -4,3 +4,4 @@ header-y  += elf.h
 generic-y += clkdev.h
 generic-y += exec.h
 generic-y += trace_clock.h
+generic-y += syscalls.h
diff --git a/arch/microblaze/include/asm/processor.h b/arch/microblaze/include/asm/processor.h
index af2bb9652392..0759153e8117 100644
--- a/arch/microblaze/include/asm/processor.h
+++ b/arch/microblaze/include/asm/processor.h
@@ -31,6 +31,7 @@ extern const struct seq_operations cpuinfo_op;
 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long usp);
 extern void ret_from_fork(void);
+extern void ret_from_kernel_thread(void);
 # endif /* __ASSEMBLY__ */
@@ -78,11 +79,6 @@ extern unsigned long thread_saved_pc(struct task_struct *t);
 extern unsigned long get_wchan(struct task_struct *p);
-/*
- * create a kernel thread without removing it from tasklists
- */
-extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 # define KSTK_EIP(tsk)  (0)
 # define KSTK_ESP(tsk)  (0)
@@ -131,8 +127,6 @@ extern inline void release_thread(struct task_struct *dead_task)
 {
 }
-extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 /* Free current thread data structures etc.  */
 static inline void exit_thread(void)
 {
diff --git a/arch/microblaze/include/asm/syscalls.h b/arch/microblaze/include/asm/syscalls.h
deleted file mode 100644
index 27f2f4c0f39f..000000000000
--- a/arch/microblaze/include/asm/syscalls.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef __ASM_MICROBLAZE_SYSCALLS_H
-asmlinkage long microblaze_vfork(struct pt_regs *regs);
-asmlinkage long microblaze_clone(int flags, unsigned long stack,
-                                                        struct pt_regs *regs);
-asmlinkage long microblaze_execve(const char __user *filenamei,
-                                  const char __user *const __user *argv,
-                                  const char __user *const __user *envp,
-                                  struct pt_regs *regs);
-asmlinkage long sys_clone(int flags, unsigned long stack, struct pt_regs *regs);
-#define sys_clone sys_clone
-#include <asm-generic/syscalls.h>
-#endif /* __ASM_MICROBLAZE_SYSCALLS_H */
diff --git a/arch/microblaze/include/asm/unistd.h b/arch/microblaze/include/asm/unistd.h
index 6985e6e9d826..94d978986b75 100644
--- a/arch/microblaze/include/asm/unistd.h
+++ b/arch/microblaze/include/asm/unistd.h
@@ -422,6 +422,12 @@
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
+#define __ARCH_WANT_SYS_VFORK
+#ifdef CONFIG_MMU
+#define __ARCH_WANT_SYS_FORK
+#endif
 /*
 * "Conditional" syscalls
diff --git a/arch/microblaze/kernel/entry-nommu.S b/arch/microblaze/kernel/entry-nommu.S
index 75c3ea1f48a1..cb0327f204ab 100644
--- a/arch/microblaze/kernel/entry-nommu.S
+++ b/arch/microblaze/kernel/entry-nommu.S
@@ -474,6 +474,14 @@ ENTRY(ret_from_fork)
        brid    ret_to_user
        nop
+ENTRY(ret_from_kernel_thread)
+        brlid   r15, schedule_tail
+        addk    r5, r0, r3
+        brald   r15, r20
+        addk    r5, r0, r19
+        brid    ret_to_user
+        addk    r3, r0, r0
 work_pending:
        enable_irq
@@ -551,18 +559,6 @@ no_work_pending:
        rtid    r14, 0
        nop
-sys_vfork:
-        brid    microblaze_vfork
-        addk    r5, r1, r0
-sys_clone:
-        brid    microblaze_clone
-        addk    r7, r1, r0
-sys_execve:
-        brid    microblaze_execve
-        addk    r8, r1, r0
 sys_rt_sigreturn_wrapper:
        brid    sys_rt_sigreturn
        addk    r5, r1, r0
diff --git a/arch/microblaze/kernel/entry.S b/arch/microblaze/kernel/entry.S
index 03f7b8ce6b6b..c217367dfc7b 100644
--- a/arch/microblaze/kernel/entry.S
+++ b/arch/microblaze/kernel/entry.S
@@ -293,24 +293,6 @@ C_ENTRY(_user_exception):
        swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
        addi    r14, r14, 4     /* return address is 4 byte after call */
-        mfs     r1, rmsr
-        nop
-        andi    r1, r1, MSR_UMS
-        bnei    r1, 1f
-/* Kernel-mode state save - kernel execve */
-        lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* Reload kernel stack-ptr*/
-        tophys(r1,r1);
-        addik   r1, r1, -PT_SIZE; /* Make room on the stack. */
-        SAVE_REGS
-        swi     r1, r1, PT_MODE; /* pt_regs -> kernel mode */
-        brid    2f;
-        nop;                            /* Fill delay slot */
-/* User-mode state save.  */
-1:
        lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
        tophys(r1,r1);
        lwi     r1, r1, TS_THREAD_INFO; /* get stack from task_struct */
@@ -460,18 +442,6 @@ TRAP_return:		/* Make global symbol for debugging */
        nop;
-/* These syscalls need access to the struct pt_regs on the stack, so we
-   implement them in assembly (they're basically all wrappers anyway).  */
-C_ENTRY(sys_fork_wrapper):
-        addi    r5, r0, SIGCHLD                 /* Arg 0: flags */
-        lwi     r6, r1, PT_R1   /* Arg 1: child SP (use parent's) */
-        addik   r7, r1, 0                       /* Arg 2: parent context */
-        add     r8, r0, r0                      /* Arg 3: (unused) */
-        add     r9, r0, r0;                     /* Arg 4: (unused) */
-        brid    do_fork         /* Do real work (tail-call) */
-        add     r10, r0, r0;                    /* Arg 5: (unused) */
 /* This the initial entry point for a new child thread, with an appropriate
   stack in place that makes it look the the child is in the middle of an
   syscall.  This function is actually `returned to' from switch_thread
@@ -479,28 +449,19 @@ C_ENTRY(sys_fork_wrapper):
   saved context).  */
 C_ENTRY(ret_from_fork):
        bralid  r15, schedule_tail; /* ...which is schedule_tail's arg */
-        add     r3, r5, r0;     /* switch_thread returns the prev task */
+        add     r5, r3, r0;     /* switch_thread returns the prev task */
                                /* ( in the delay slot ) */
        brid    ret_from_trap;  /* Do normal trap return */
        add     r3, r0, r0;     /* Child's fork call should return 0. */
-C_ENTRY(sys_vfork):
+C_ENTRY(ret_from_kernel_thread):
-        brid    microblaze_vfork        /* Do real work (tail-call) */
+        bralid  r15, schedule_tail; /* ...which is schedule_tail's arg */
-        addik   r5, r1, 0
+        add     r5, r3, r0;     /* switch_thread returns the prev task */
+                                /* ( in the delay slot ) */
-C_ENTRY(sys_clone):
+        brald   r15, r20        /* fn was left in r20 */
-        bnei    r6, 1f;                 /* See if child SP arg (arg 1) is 0. */
+        addk    r5, r0, r19     /* ... and argument - in r19 */
-        lwi     r6, r1, PT_R1;  /* If so, use paret's stack ptr */
+        brid    ret_from_trap
-1:      addik   r7, r1, 0;                      /* Arg 2: parent context */
+        add     r3, r0, r0
-        lwi     r9, r1, PT_R8;          /* parent tid.  */
-        lwi     r10, r1, PT_R9;         /* child tid.  */
-        /* do_fork will pick up TLS from regs->r10.  */
-        brid    do_fork         /* Do real work (tail-call) */
-        add     r8, r0, r0;             /* Arg 3: (unused) */
-C_ENTRY(sys_execve):
-        brid    microblaze_execve;      /* Do real work (tail-call).*/
-        addik   r8, r1, 0;              /* add user context as 4th arg */
 C_ENTRY(sys_rt_sigreturn_wrapper):
        brid    sys_rt_sigreturn        /* Do real work */
diff --git a/arch/microblaze/kernel/process.c b/arch/microblaze/kernel/process.c
index 1944e00f07e1..40823fd1db0b 100644
--- a/arch/microblaze/kernel/process.c
+++ b/arch/microblaze/kernel/process.c
@@ -13,6 +13,7 @@
 #include <linux/pm.h>
 #include <linux/tick.h>
 #include <linux/bitops.h>
+#include <linux/ptrace.h>
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h> /* for USER_DS macros */
 #include <asm/cacheflush.h>
@@ -119,46 +120,38 @@ void flush_thread(void)
 }
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct pt_regs *childregs = task_pt_regs(p);
        struct thread_info *ti = task_thread_info(p);
-        *childregs = *regs;
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        if (user_mode(regs))
+                /* if we're creating a new kernel thread then just zeroing all
+                 * the registers. That's OK for a brand new thread.*/
+                memset(childregs, 0, sizeof(struct pt_regs));
+                memset(&ti->cpu_context, 0, sizeof(struct cpu_context));
+                ti->cpu_context.r1  = (unsigned long)childregs;
+                ti->cpu_context.r20 = (unsigned long)usp; /* fn */
+                ti->cpu_context.r19 = (unsigned long)arg;
+                childregs->pt_mode = 1;
+                local_save_flags(childregs->msr);
+#ifdef CONFIG_MMU
+                ti->cpu_context.msr = childregs->msr & ~MSR_IE;
+#endif
+                ti->cpu_context.r15 = (unsigned long)ret_from_kernel_thread - 8;
+                return 0;
+        }
+        *childregs = *current_pt_regs();
+        if (usp)
                childregs->r1 = usp;
-        else
-                childregs->r1 = ((unsigned long) ti) + THREAD_SIZE;
-#ifndef CONFIG_MMU
        memset(&ti->cpu_context, 0, sizeof(struct cpu_context));
        ti->cpu_context.r1 = (unsigned long)childregs;
+#ifndef CONFIG_MMU
        ti->cpu_context.msr = (unsigned long)childregs->msr;
 #else
+        childregs->msr |= MSR_UMS;
-        /* if creating a kernel thread then update the current reg (we don't
-         * want to use the parent's value when restoring by POP_STATE) */
-        if (kernel_mode(regs))
-                /* save new current on stack to use POP_STATE */
-                childregs->CURRENT_TASK = (unsigned long)p;
-        /* if returning to user then use the parent's value of this register */
-        /* if we're creating a new kernel thread then just zeroing all
-         * the registers. That's OK for a brand new thread.*/
-        /* Pls. note that some of them will be restored in POP_STATE */
-        if (kernel_mode(regs))
-                memset(&ti->cpu_context, 0, sizeof(struct cpu_context));
-        /* if this thread is created for fork/vfork/clone, then we want to
-         * restore all the parent's context */
-        /* in addition to the registers which will be restored by POP_STATE */
-        else {
-                ti->cpu_context = *(struct cpu_context *)regs;
-                childregs->msr |= MSR_UMS;
-        }
-        /* FIXME STATE_SAVE_PT_OFFSET; */
-        ti->cpu_context.r1  = (unsigned long)childregs;
        /* we should consider the fact that childregs is a copy of the parent
         * regs which were saved immediately after entering the kernel state
         * before enabling VM. This MSR will be restored in switch_to and
@@ -209,29 +202,6 @@ unsigned long thread_saved_pc(struct task_struct *tsk)
 }
 #endif
-static void kernel_thread_helper(int (*fn)(void *), void *arg)
-{
-        fn(arg);
-        do_exit(-1);
-}
-int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        /* store them in non-volatile registers */
-        regs.r5 = (unsigned long)fn;
-        regs.r6 = (unsigned long)arg;
-        local_save_flags(regs.msr);
-        regs.pc = (unsigned long)kernel_thread_helper;
-        regs.pt_mode = 1;
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0,
-                        &regs, 0, NULL, NULL);
-}
-EXPORT_SYMBOL_GPL(kernel_thread);
 unsigned long get_wchan(struct task_struct *p)
 {
 /* TBD (used by procfs) */
@@ -246,6 +216,7 @@ void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long usp)
        regs->pt_mode = 0;
 #ifdef CONFIG_MMU
        regs->msr |= MSR_UMS;
+        regs->msr &= ~MSR_VM;
 #endif
 }
diff --git a/arch/microblaze/kernel/sys_microblaze.c b/arch/microblaze/kernel/sys_microblaze.c
index 404c0f24bd41..63647c586b43 100644
--- a/arch/microblaze/kernel/sys_microblaze.c
+++ b/arch/microblaze/kernel/sys_microblaze.c
@@ -34,38 +34,6 @@
 #include <asm/syscalls.h>
-asmlinkage long microblaze_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->r1,
-                                                regs, 0, NULL, NULL);
-}
-asmlinkage long microblaze_clone(int flags, unsigned long stack,
-                                                        struct pt_regs *regs)
-{
-        if (!stack)
-                stack = regs->r1;
-        return do_fork(flags, stack, regs, 0, NULL, NULL);
-}
-asmlinkage long microblaze_execve(const char __user *filenamei,
-                                  const char __user *const __user *argv,
-                                  const char __user *const __user *envp,
-                                  struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(filenamei);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-out:
-        return error;
-}
 asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
                        unsigned long prot, unsigned long flags,
                        unsigned long fd, off_t pgoff)
@@ -75,24 +43,3 @@ asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
        return sys_mmap_pgoff(addr, len, prot, flags, fd, pgoff >> PAGE_SHIFT);
 }
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register const char *__a __asm__("r5") = filename;
-        register const void *__b __asm__("r6") = argv;
-        register const void *__c __asm__("r7") = envp;
-        register unsigned long __syscall __asm__("r12") = __NR_execve;
-        register unsigned long __ret __asm__("r3");
-        __asm__ __volatile__ ("brki r14, 0x8"
-                        : "=r" (__ret), "=r" (__syscall)
-                        : "1" (__syscall), "r" (__a), "r" (__b), "r" (__c)
-                        : "r4", "r8", "r9",
-                        "r10", "r11", "r14", "cc", "memory");
-        return __ret;
-}
diff --git a/arch/microblaze/kernel/syscall_table.S b/arch/microblaze/kernel/syscall_table.S
index 6a2b294ef6dc..ff6431e54680 100644
--- a/arch/microblaze/kernel/syscall_table.S
+++ b/arch/microblaze/kernel/syscall_table.S
@@ -2,11 +2,7 @@ ENTRY(sys_call_table)
        .long sys_restart_syscall       /* 0 - old "setup()" system call,
                                         * used for restarting */
        .long sys_exit
-#ifdef CONFIG_MMU
+        .long sys_fork
-        .long sys_fork_wrapper
-#else
-        .long sys_ni_syscall
-#endif
        .long sys_read
        .long sys_write
        .long sys_open                  /* 5 */
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index dba9390d37cf..4183e62f178c 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -40,6 +40,8 @@ config MIPS
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_REL
        select MODULES_USE_ELF_RELA if 64BIT
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 menu "Machine selection"
diff --git a/arch/mips/include/asm/processor.h b/arch/mips/include/asm/processor.h
index 5e33fabe354d..d28c41e0887c 100644
--- a/arch/mips/include/asm/processor.h
+++ b/arch/mips/include/asm/processor.h
@@ -310,8 +310,6 @@ struct task_struct;
 /* Free all resources held by a thread. */
 #define release_thread(thread) do { } while(0)
-extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 extern unsigned long thread_saved_pc(struct task_struct *tsk);
 /*
diff --git a/arch/mips/include/asm/ptrace.h b/arch/mips/include/asm/ptrace.h
index 4f5da948a777..cec5e125f7e4 100644
--- a/arch/mips/include/asm/ptrace.h
+++ b/arch/mips/include/asm/ptrace.h
@@ -61,4 +61,10 @@ static inline void die_if_kernel(const char *str, struct pt_regs *regs)
                die(str, regs);
 }
+#define current_pt_regs()                                               \
+({                                                                      \
+        unsigned long sp = (unsigned long)__builtin_frame_address(0);   \
+        (struct pt_regs *)((sp | (THREAD_SIZE - 1)) + 1 - 32) - 1;      \
+})
 #endif /* _ASM_PTRACE_H */
diff --git a/arch/mips/include/asm/signal.h b/arch/mips/include/asm/signal.h
index 880240dff8b7..cf4a08062d1d 100644
--- a/arch/mips/include/asm/signal.h
+++ b/arch/mips/include/asm/signal.h
@@ -21,6 +21,4 @@
 #include <asm/sigcontext.h>
 #include <asm/siginfo.h>
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* _ASM_SIGNAL_H */
diff --git a/arch/mips/include/asm/unistd.h b/arch/mips/include/asm/unistd.h
index 9e47cc11aa26..b306e2081cad 100644
--- a/arch/mips/include/asm/unistd.h
+++ b/arch/mips/include/asm/unistd.h
@@ -20,6 +20,7 @@
 #define __ARCH_OMIT_COMPAT_SYS_GETDENTS64
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_SYS_ALARM
+#define __ARCH_WANT_SYS_EXECVE
 #define __ARCH_WANT_SYS_GETHOSTNAME
 #define __ARCH_WANT_SYS_IPC
 #define __ARCH_WANT_SYS_PAUSE
diff --git a/arch/mips/kernel/entry.S b/arch/mips/kernel/entry.S
index 9b00362f32f6..e5786858cdb6 100644
--- a/arch/mips/kernel/entry.S
+++ b/arch/mips/kernel/entry.S
@@ -70,6 +70,12 @@ need_resched:
        b       need_resched
 #endif
+FEXPORT(ret_from_kernel_thread)
+        jal     schedule_tail           # a0 = struct task_struct *prev
+        move    a0, s1
+        jal     s0
+        j       syscall_exit
 FEXPORT(ret_from_fork)
        jal     schedule_tail           # a0 = struct task_struct *prev
diff --git a/arch/mips/kernel/linux32.c b/arch/mips/kernel/linux32.c
index 3a21acedf882..7adab86c632c 100644
--- a/arch/mips/kernel/linux32.c
+++ b/arch/mips/kernel/linux32.c
@@ -3,7 +3,6 @@
 *
 * Copyright (C) 2000 Silicon Graphics, Inc.
 * Written by Ulf Carlsson (ulfc@engr.sgi.com)
- * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com)
 */
 #include <linux/compiler.h>
 #include <linux/mm.h>
@@ -77,26 +76,6 @@ out:
        return error;
 }
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(compat_ptr(regs.regs[4]));
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = compat_do_execve(filename->name, compat_ptr(regs.regs[5]),
-                                 compat_ptr(regs.regs[6]), &regs);
-        putname(filename);
-out:
-        return error;
-}
 #define RLIM_INFINITY32 0x7fffffff
 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
@@ -333,7 +312,7 @@ _sys32_clone(nabi_no_regargs struct pt_regs regs)
        /* Use __dummy4 instead of getting it off the stack, so that
           syscall() works.  */
        child_tidptr = (int __user *) __dummy4;
-        return do_fork(clone_flags, newsp, &regs, 0,
+        return do_fork(clone_flags, newsp, 0,
                       parent_tidptr, child_tidptr);
 }
diff --git a/arch/mips/kernel/mips_ksyms.c b/arch/mips/kernel/mips_ksyms.c
index 3fc1691110dc..2d9304c2b54c 100644
--- a/arch/mips/kernel/mips_ksyms.c
+++ b/arch/mips/kernel/mips_ksyms.c
@@ -32,8 +32,6 @@ EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(memmove);
-EXPORT_SYMBOL(kernel_thread);
 /*
 * Functions that operate on entire pages.  Mostly used by memory management.
 */
diff --git a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c
index e9a5fd7277f4..38097652d62d 100644
--- a/arch/mips/kernel/process.c
+++ b/arch/mips/kernel/process.c
@@ -84,6 +84,7 @@ void __noreturn cpu_idle(void)
 }
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
 void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
 {
@@ -113,10 +114,10 @@ void flush_thread(void)
 }
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-        unsigned long unused, struct task_struct *p, struct pt_regs *regs)
+        unsigned long arg, struct task_struct *p)
 {
        struct thread_info *ti = task_thread_info(p);
-        struct pt_regs *childregs;
+        struct pt_regs *childregs, *regs = current_pt_regs();
        unsigned long childksp;
        p->set_child_tid = p->clear_child_tid = NULL;
@@ -136,19 +137,30 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        childregs = (struct pt_regs *) childksp - 1;
        /*  Put the stack after the struct pt_regs.  */
        childksp = (unsigned long) childregs;
+        p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                unsigned long status = p->thread.cp0_status;
+                memset(childregs, 0, sizeof(struct pt_regs));
+                ti->addr_limit = KERNEL_DS;
+                p->thread.reg16 = usp; /* fn */
+                p->thread.reg17 = arg;
+                p->thread.reg29 = childksp;
+                p->thread.reg31 = (unsigned long) ret_from_kernel_thread;
+#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
+                status = (status & ~(ST0_KUP | ST0_IEP | ST0_IEC)) |
+                         ((status & (ST0_KUC | ST0_IEC)) << 2);
+#else
+                status |= ST0_EXL;
+#endif
+                childregs->cp0_status = status;
+                return 0;
+        }
        *childregs = *regs;
        childregs->regs[7] = 0; /* Clear error flag */
        childregs->regs[2] = 0; /* Child gets zero as return value */
+        childregs->regs[29] = usp;
+        ti->addr_limit = USER_DS;
-        if (childregs->cp0_status & ST0_CU0) {
-                childregs->regs[28] = (unsigned long) ti;
-                childregs->regs[29] = childksp;
-                ti->addr_limit = KERNEL_DS;
-        } else {
-                childregs->regs[29] = usp;
-                ti->addr_limit = USER_DS;
-        }
        p->thread.reg29 = (unsigned long) childregs;
        p->thread.reg31 = (unsigned long) ret_from_fork;
@@ -156,7 +168,6 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         * New tasks lose permission to use the fpu. This accelerates context
         * switching for most programs since they don't use the fpu.
         */
-        p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
        childregs->cp0_status &= ~(ST0_CU2|ST0_CU1);
 #ifdef CONFIG_MIPS_MT_SMTC
@@ -222,35 +233,6 @@ int dump_task_fpu(struct task_struct *t, elf_fpregset_t *fpr)
 }
 /*
- * Create a kernel thread
- */
-static void __noreturn kernel_thread_helper(void *arg, int (*fn)(void *))
-{
-        do_exit(fn(arg));
-}
-long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.regs[4] = (unsigned long) arg;
-        regs.regs[5] = (unsigned long) fn;
-        regs.cp0_epc = (unsigned long) kernel_thread_helper;
-        regs.cp0_status = read_c0_status();
-#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
-        regs.cp0_status = (regs.cp0_status & ~(ST0_KUP | ST0_IEP | ST0_IEC)) |
-                          ((regs.cp0_status & (ST0_KUC | ST0_IEC)) << 2);
-#else
-        regs.cp0_status |= ST0_EXL;
-#endif
-        /* Ok, create the new process.. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
-}
-/*
 *
 */
 struct mips_frame_info {
diff --git a/arch/mips/kernel/scall64-n32.S b/arch/mips/kernel/scall64-n32.S
index 86ec03f0e00c..629719143763 100644
--- a/arch/mips/kernel/scall64-n32.S
+++ b/arch/mips/kernel/scall64-n32.S
@@ -167,7 +167,7 @@ EXPORT(sysn32_call_table)
        PTR     sys_getsockopt
        PTR     sys_clone                       /* 6055 */
        PTR     sys_fork
-        PTR     sys32_execve
+        PTR     compat_sys_execve
        PTR     sys_exit
        PTR     compat_sys_wait4
        PTR     sys_kill                        /* 6060 */
diff --git a/arch/mips/kernel/scall64-o32.S b/arch/mips/kernel/scall64-o32.S
index 53c2d7245764..9601be6afa3d 100644
--- a/arch/mips/kernel/scall64-o32.S
+++ b/arch/mips/kernel/scall64-o32.S
@@ -203,7 +203,7 @@ sys_call_table:
        PTR     sys_creat
        PTR     sys_link
        PTR     sys_unlink                      /* 4010 */
-        PTR     sys32_execve
+        PTR     compat_sys_execve
        PTR     sys_chdir
        PTR     compat_sys_time
        PTR     sys_mknod
diff --git a/arch/mips/kernel/syscall.c b/arch/mips/kernel/syscall.c
index 2bd561bc05ae..201cb76b4df9 100644
--- a/arch/mips/kernel/syscall.c
+++ b/arch/mips/kernel/syscall.c
@@ -92,7 +92,7 @@ save_static_function(sys_fork);
 static int __used noinline
 _sys_fork(nabi_no_regargs struct pt_regs regs)
 {
-        return do_fork(SIGCHLD, regs.regs[29], &regs, 0, NULL, NULL);
+        return do_fork(SIGCHLD, regs.regs[29], 0, NULL, NULL);
 }
 save_static_function(sys_clone);
@@ -123,32 +123,10 @@ _sys_clone(nabi_no_regargs struct pt_regs regs)
 #else
        child_tidptr = (int __user *) regs.regs[8];
 #endif
-        return do_fork(clone_flags, newsp, &regs, 0,
+        return do_fork(clone_flags, newsp, 0,
                       parent_tidptr, child_tidptr);
 }
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(nabi_no_regargs struct pt_regs regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname((const char __user *) (long)regs.regs[4]);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name,
-                          (const char __user *const __user *) (long)regs.regs[5],
-                          (const char __user *const __user *) (long)regs.regs[6],
-                          &regs);
-        putname(filename);
-out:
-        return error;
-}
 SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)
 {
        struct thread_info *ti = task_thread_info(current);
@@ -313,34 +291,3 @@ asmlinkage void bad_stack(void)
 {
        do_exit(SIGSEGV);
 }
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register unsigned long __a0 asm("$4") = (unsigned long) filename;
-        register unsigned long __a1 asm("$5") = (unsigned long) argv;
-        register unsigned long __a2 asm("$6") = (unsigned long) envp;
-        register unsigned long __a3 asm("$7");
-        unsigned long __v0;
-        __asm__ volatile ("                                     \n"
-        "       .set    noreorder                               \n"
-        "       li      $2, %5          # __NR_execve           \n"
-        "       syscall                                         \n"
-        "       move    %0, $2                                  \n"
-        "       .set    reorder                                 \n"
-        : "=&r" (__v0), "=r" (__a3)
-        : "r" (__a0), "r" (__a1), "r" (__a2), "i" (__NR_execve)
-        : "$2", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24",
-          "memory");
-        if (__a3 == 0)
-                return __v0;
-        return -__v0;
-}
diff --git a/arch/mn10300/Kconfig b/arch/mn10300/Kconfig
index 04669fac117b..72471744a912 100644
--- a/arch/mn10300/Kconfig
+++ b/arch/mn10300/Kconfig
@@ -9,6 +9,7 @@ config MN10300
        select HAVE_NMI_WATCHDOG if MN10300_WD_TIMER
        select GENERIC_CLOCKEVENTS
        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        select MODULES_USE_ELF_RELA
 config AM33_2
diff --git a/arch/mn10300/include/asm/signal.h b/arch/mn10300/include/asm/signal.h
index f9668ec3040c..d280e9780793 100644
--- a/arch/mn10300/include/asm/signal.h
+++ b/arch/mn10300/include/asm/signal.h
@@ -45,8 +45,4 @@ struct k_sigaction {
 };
 #include <asm/sigcontext.h>
-struct pt_regs;
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* _ASM_SIGNAL_H */
diff --git a/arch/mn10300/include/asm/unistd.h b/arch/mn10300/include/asm/unistd.h
index 55bbec1887e9..cabf8ba73b27 100644
--- a/arch/mn10300/include/asm/unistd.h
+++ b/arch/mn10300/include/asm/unistd.h
@@ -44,7 +44,9 @@
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_SYS_EXECVE
-#define __ARCH_WANT_KERNEL_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/mn10300/kernel/entry.S b/arch/mn10300/kernel/entry.S
index 0c631d34c8d7..68fcab8f8f6f 100644
--- a/arch/mn10300/kernel/entry.S
+++ b/arch/mn10300/kernel/entry.S
@@ -60,13 +60,8 @@ ENTRY(ret_from_kernel_thread)
        mov     (REG_D0,fp),d0
        mov     (REG_A0,fp),a0
        calls   (a0)
-        jmp     sys_exit
-ENTRY(ret_from_kernel_execve)
-        add     -12,d0  /* pt_regs -> frame */
-        mov     d0,sp
-        GET_THREAD_INFO a2
        clr     d0
+        mov     d0,(REG_D0,fp)
        jmp     syscall_exit
 ###############################################################################
diff --git a/arch/mn10300/kernel/process.c b/arch/mn10300/kernel/process.c
index d0c671b6d9ff..eb09f5a552ff 100644
--- a/arch/mn10300/kernel/process.c
+++ b/arch/mn10300/kernel/process.c
@@ -206,7 +206,7 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 */
 int copy_thread(unsigned long clone_flags,
                unsigned long c_usp, unsigned long ustk_size,
-                struct task_struct *p, struct pt_regs *kregs)
+                struct task_struct *p)
 {
        struct thread_info *ti = task_thread_info(p);
        struct pt_regs *c_regs;
@@ -227,7 +227,7 @@ int copy_thread(unsigned long clone_flags,
        p->thread.wchan = p->thread.pc;
        p->thread.usp   = c_usp;
-        if (unlikely(!kregs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                memset(c_regs, 0, sizeof(struct pt_regs));
                c_regs->a0 = c_usp; /* function */
                c_regs->d0 = ustk_size; /* argument */
@@ -236,8 +236,9 @@ int copy_thread(unsigned long clone_flags,
                p->thread.pc    = (unsigned long) ret_from_kernel_thread;
                return 0;
        }
-        *c_regs = *kregs;
+        *c_regs = *current_pt_regs();
-        c_regs->sp = c_usp;
+        if (c_usp)
+                c_regs->sp = c_usp;
        c_regs->epsw &= ~EPSW_FE; /* my FPU */
        /* the new TLS pointer is passed in as arg #5 to sys_clone() */
@@ -249,30 +250,6 @@ int copy_thread(unsigned long clone_flags,
        return 0;
 }
-/*
- * clone a process
- * - tlsptr is retrieved by copy_thread() from current_frame()->d3
- */
-asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
-                          int __user *parent_tidptr, int __user *child_tidptr,
-                          int __user *tlsptr)
-{
-        return do_fork(clone_flags, newsp ?: current_frame()->sp,
-                       current_frame(), 0, parent_tidptr, child_tidptr);
-}
-asmlinkage long sys_fork(void)
-{
-        return do_fork(SIGCHLD, current_frame()->sp,
-                       current_frame(), 0, NULL, NULL);
-}
-asmlinkage long sys_vfork(void)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, current_frame()->sp,
-                       current_frame(), 0, NULL, NULL);
-}
 unsigned long get_wchan(struct task_struct *p)
 {
        return p->thread.wchan;
diff --git a/arch/openrisc/Kconfig b/arch/openrisc/Kconfig
index 05f2ba41ff1a..e7f1a2993f78 100644
--- a/arch/openrisc/Kconfig
+++ b/arch/openrisc/Kconfig
@@ -22,6 +22,8 @@ config OPENRISC
        select GENERIC_STRNCPY_FROM_USER
        select GENERIC_STRNLEN_USER
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 config MMU
        def_bool y
diff --git a/arch/openrisc/include/asm/processor.h b/arch/openrisc/include/asm/processor.h
index 43decdbdb2ed..33691380608e 100644
--- a/arch/openrisc/include/asm/processor.h
+++ b/arch/openrisc/include/asm/processor.h
@@ -81,8 +81,6 @@ struct thread_struct {
 #define KSTK_ESP(tsk)   (task_pt_regs(tsk)->sp)
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 void start_thread(struct pt_regs *regs, unsigned long nip, unsigned long sp);
 void release_thread(struct task_struct *);
 unsigned long get_wchan(struct task_struct *p);
diff --git a/arch/openrisc/include/asm/syscalls.h b/arch/openrisc/include/asm/syscalls.h
index 84a978af44d7..8ee816812a9e 100644
--- a/arch/openrisc/include/asm/syscalls.h
+++ b/arch/openrisc/include/asm/syscalls.h
@@ -24,4 +24,11 @@ asmlinkage long sys_or1k_atomic(unsigned long type, unsigned long *v1,
 #include <asm-generic/syscalls.h>
+asmlinkage long __sys_clone(unsigned long clone_flags, unsigned long newsp,
+                        void __user *parent_tid, void __user *child_tid, int tls);
+asmlinkage long __sys_fork(void);
+#define sys_clone __sys_clone
+#define sys_fork __sys_fork
 #endif /* __ASM_OPENRISC_SYSCALLS_H */
diff --git a/arch/openrisc/include/uapi/asm/unistd.h b/arch/openrisc/include/uapi/asm/unistd.h
index 437bdbb61b14..5082b8066325 100644
--- a/arch/openrisc/include/uapi/asm/unistd.h
+++ b/arch/openrisc/include/uapi/asm/unistd.h
@@ -20,6 +20,10 @@
 #define sys_mmap2 sys_mmap_pgoff
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_CLONE
 #include <asm-generic/unistd.h>
 #define __NR_or1k_atomic __NR_arch_specific_syscall
diff --git a/arch/openrisc/kernel/Makefile b/arch/openrisc/kernel/Makefile
index e1ee0fa2bbda..35f92ce51c24 100644
--- a/arch/openrisc/kernel/Makefile
+++ b/arch/openrisc/kernel/Makefile
@@ -5,7 +5,7 @@
 extra-y := head.o vmlinux.lds
 obj-y   := setup.o idle.o or32_ksyms.o process.o dma.o \
-           traps.o time.o irq.o entry.o ptrace.o signal.o sys_or32.o \
+           traps.o time.o irq.o entry.o ptrace.o signal.o \
           sys_call_table.o
 obj-$(CONFIG_MODULES)           += module.o
diff --git a/arch/openrisc/kernel/entry.S b/arch/openrisc/kernel/entry.S
index ddfcaa828b0e..5e5b30601bbf 100644
--- a/arch/openrisc/kernel/entry.S
+++ b/arch/openrisc/kernel/entry.S
@@ -894,6 +894,16 @@ ENTRY(ret_from_fork)
        l.jal   schedule_tail
         l.nop
+        /* Check if we are a kernel thread */
+        l.sfeqi r20,0
+        l.bf    1f
+         l.nop
+        /* ...we are a kernel thread so invoke the requested callback */
+        l.jalr  r20
+         l.or   r3,r22,r0
+1:
        /* _syscall_returns expect r11 to contain return value */
        l.lwz   r11,PT_GPR11(r1)
@@ -915,26 +925,6 @@ ENTRY(ret_from_fork)
        l.j     _syscall_return
         l.nop
-/* Since syscalls don't save call-clobbered registers, the args to
- * kernel_thread_helper will need to be passed through callee-saved
- * registers and copied to the parameter registers when the thread
- * begins running.
- *
- * See arch/openrisc/kernel/process.c:
- * The args are passed as follows:
- *   arg1 (r3) : passed in r20
- *   arg2 (r4) : passed in r22
- */
-ENTRY(_kernel_thread_helper)
-        l.or    r3,r20,r0
-        l.or    r4,r22,r0
-        l.movhi r31,hi(kernel_thread_helper)
-        l.ori   r31,r31,lo(kernel_thread_helper)
-        l.jr    r31
-         l.nop
 /* ========================================================[ switch ] === */
 /*
@@ -1044,8 +1034,13 @@ ENTRY(_switch)
        /* Unwind stack to pre-switch state */
        l.addi  r1,r1,(INT_FRAME_SIZE)
-        /* Return via the link-register back to where we 'came from', where that can be
+        /* Return via the link-register back to where we 'came from', where
-         * either schedule() or return_from_fork()... */
+         * that may be either schedule(), ret_from_fork(), or
+         * ret_from_kernel_thread().  If we are returning to a new thread,
+         * we are expected to have set up the arg to schedule_tail already,
+         * hence we do so here unconditionally:
+         */
+        l.lwz   r3,TI_STACK(r3)         /* Load 'prev' as schedule_tail arg */
        l.jr    r9
         l.nop
@@ -1076,22 +1071,18 @@ _fork_save_extra_regs_and_call:
        l.jr    r29
         l.sw    PT_GPR28(r1),r28
-ENTRY(sys_clone)
+ENTRY(__sys_clone)
-        l.movhi r29,hi(_sys_clone)
+        l.movhi r29,hi(sys_clone)
-        l.ori   r29,r29,lo(_sys_clone)
+        l.ori   r29,r29,lo(sys_clone)
        l.j     _fork_save_extra_regs_and_call
         l.addi r7,r1,0
-ENTRY(sys_fork)
+ENTRY(__sys_fork)
-        l.movhi r29,hi(_sys_fork)
+        l.movhi r29,hi(sys_fork)
-        l.ori   r29,r29,lo(_sys_fork)
+        l.ori   r29,r29,lo(sys_fork)
        l.j     _fork_save_extra_regs_and_call
         l.addi r3,r1,0
-ENTRY(sys_execve)
-        l.j     _sys_execve
-         l.addi r6,r1,0
 ENTRY(sys_sigaltstack)
        l.j     _sys_sigaltstack
         l.addi r5,r1,0
diff --git a/arch/openrisc/kernel/process.c b/arch/openrisc/kernel/process.c
index c35f3ab1a8d3..00c233bf0d06 100644
--- a/arch/openrisc/kernel/process.c
+++ b/arch/openrisc/kernel/process.c
@@ -109,66 +109,83 @@ void release_thread(struct task_struct *dead_task)
 */
 extern asmlinkage void ret_from_fork(void);
+/*
+ * copy_thread
+ * @clone_flags: flags
+ * @usp: user stack pointer or fn for kernel thread
+ * @arg: arg to fn for kernel thread; always NULL for userspace thread
+ * @p: the newly created task
+ * @regs: CPU context to copy for userspace thread; always NULL for kthread
+ *
+ * At the top of a newly initialized kernel stack are two stacked pt_reg
+ * structures.  The first (topmost) is the userspace context of the thread.
+ * The second is the kernelspace context of the thread.
+ *
+ * A kernel thread will not be returning to userspace, so the topmost pt_regs
+ * struct can be uninitialized; it _does_ need to exist, though, because
+ * a kernel thread can become a userspace thread by doing a kernel_execve, in
+ * which case the topmost context will be initialized and used for 'returning'
+ * to userspace.
+ *
+ * The second pt_reg struct needs to be initialized to 'return' to
+ * ret_from_fork.  A kernel thread will need to set r20 to the address of
+ * a function to call into (with arg in r22); userspace threads need to set
+ * r20 to NULL in which case ret_from_fork will just continue a return to
+ * userspace.
+ *
+ * A kernel thread 'fn' may return; this is effectively what happens when
+ * kernel_execve is called.  In that case, the userspace pt_regs must have
+ * been initialized (which kernel_execve takes care of, see start_thread
+ * below); ret_from_fork will then continue its execution causing the
+ * 'kernel thread' to return to userspace as a userspace thread.
+ */
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-            unsigned long unused, struct task_struct *p, struct pt_regs *regs)
+            unsigned long arg, struct task_struct *p)
 {
-        struct pt_regs *childregs;
+        struct pt_regs *userregs;
        struct pt_regs *kregs;
        unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;
-        struct thread_info *ti;
        unsigned long top_of_kernel_stack;
        top_of_kernel_stack = sp;
        p->set_child_tid = p->clear_child_tid = NULL;
-        /* Copy registers */
+        /* Locate userspace context on stack... */
-        /* redzone */
+        sp -= STACK_FRAME_OVERHEAD;     /* redzone */
-        sp -= STACK_FRAME_OVERHEAD;
        sp -= sizeof(struct pt_regs);
-        childregs = (struct pt_regs *)sp;
+        userregs = (struct pt_regs *) sp;
-        /* Copy parent registers */
+        /* ...and kernel context */
-        *childregs = *regs;
+        sp -= STACK_FRAME_OVERHEAD;     /* redzone */
+        sp -= sizeof(struct pt_regs);
+        kregs = (struct pt_regs *)sp;
-        if ((childregs->sr & SPR_SR_SM) == 1) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
-                /* for kernel thread, set `current_thread_info'
+                memset(kregs, 0, sizeof(struct pt_regs));
-                 * and stackptr in new task
+                kregs->gpr[20] = usp; /* fn, kernel thread */
-                 */
+                kregs->gpr[22] = arg;
-                childregs->sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;
-                childregs->gpr[10] = (unsigned long)task_thread_info(p);
        } else {
-                childregs->sp = usp;
+                *userregs = *current_pt_regs();
-        }
-        childregs->gpr[11] = 0; /* Result from fork() */
-        /*
+                if (usp)
-         * The way this works is that at some point in the future
+                        userregs->sp = usp;
-         * some task will call _switch to switch to the new task.
+                userregs->gpr[11] = 0;  /* Result from fork() */
-         * That will pop off the stack frame created below and start
-         * the new task running at ret_from_fork.  The new task will
-         * do some house keeping and then return from the fork or clone
-         * system call, using the stack frame created above.
-         */
-        /* redzone */
-        sp -= STACK_FRAME_OVERHEAD;
-        sp -= sizeof(struct pt_regs);
-        kregs = (struct pt_regs *)sp;
-        ti = task_thread_info(p);
+                kregs->gpr[20] = 0;     /* Userspace thread */
-        ti->ksp = sp;
+        }
-        /* kregs->sp must store the location of the 'pre-switch' kernel stack
+        /*
-         * pointer... for a newly forked process, this is simply the top of
+         * _switch wants the kernel stack page in pt_regs->sp so that it
-         * the kernel stack.
+         * can restore it to thread_info->ksp... see _switch for details.
         */
        kregs->sp = top_of_kernel_stack;
-        kregs->gpr[3] = (unsigned long)current; /* arg to schedule_tail */
-        kregs->gpr[10] = (unsigned long)task_thread_info(p);
        kregs->gpr[9] = (unsigned long)ret_from_fork;
+        task_thread_info(p)->ksp = (unsigned long)kregs;
        return 0;
 }
@@ -177,16 +194,14 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
 */
 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
 {
-        unsigned long sr = regs->sr & ~SPR_SR_SM;
+        unsigned long sr = mfspr(SPR_SR) & ~SPR_SR_SM;
        set_fs(USER_DS);
-        memset(regs->gpr, 0, sizeof(regs->gpr));
+        memset(regs, 0, sizeof(struct pt_regs));
        regs->pc = pc;
        regs->sr = sr;
        regs->sp = sp;
-/*      printk("start thread, ksp = %lx\n", current_thread_info()->ksp);*/
 }
 /* Fill in the fpu structure for a core dump.  */
@@ -237,74 +252,9 @@ void dump_elf_thread(elf_greg_t *dest, struct pt_regs* regs)
        dest[35] = 0;
 }
-extern void _kernel_thread_helper(void);
-void __noreturn kernel_thread_helper(int (*fn) (void *), void *arg)
-{
-        do_exit(fn(arg));
-}
-/*
- * Create a kernel thread.
- */
-int kernel_thread(int (*fn) (void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.gpr[20] = (unsigned long)fn;
-        regs.gpr[22] = (unsigned long)arg;
-        regs.sr = mfspr(SPR_SR);
-        regs.pc = (unsigned long)_kernel_thread_helper;
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
-                       0, &regs, 0, NULL, NULL);
-}
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage long _sys_execve(const char __user *name,
-                            const char __user * const __user *argv,
-                            const char __user * const __user *envp,
-                            struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname(name);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-out:
-        return error;
-}
 unsigned long get_wchan(struct task_struct *p)
 {
        /* TODO */
        return 0;
 }
-int kernel_execve(const char *filename, char *const argv[], char *const envp[])
-{
-        register long __res asm("r11") = __NR_execve;
-        register long __a asm("r3") = (long)(filename);
-        register long __b asm("r4") = (long)(argv);
-        register long __c asm("r5") = (long)(envp);
-        __asm__ volatile ("l.sys 1"
-                          : "=r" (__res), "=r"(__a), "=r"(__b), "=r"(__c)
-                          : "0"(__res), "1"(__a), "2"(__b), "3"(__c)
-                          : "r6", "r7", "r8", "r12", "r13", "r15",
-                            "r17", "r19", "r21", "r23", "r25", "r27",
-                            "r29", "r31");
-        __asm__ volatile ("l.nop");
-        return __res;
-}
diff --git a/arch/openrisc/kernel/sys_or32.c b/arch/openrisc/kernel/sys_or32.c
deleted file mode 100644
index 57060084c0cc..000000000000
--- a/arch/openrisc/kernel/sys_or32.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * OpenRISC sys_or32.c
- *
- * Linux architectural port borrowing liberally from similar works of
- * others.  All original copyrights apply as per the original source
- * declaration.
- *
- * Modifications for the OpenRISC architecture:
- * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
- * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- * This file contains various random system calls that
- * have a non-standard calling sequence on some platforms.
- * Since we don't have to do any backwards compatibility, our
- * versions are done in the most "normal" way possible.
- */
-#include <linux/errno.h>
-#include <linux/syscalls.h>
-#include <linux/mm.h>
-#include <asm/syscalls.h>
-/* These are secondary entry points as the primary entry points are defined in
- * entry.S where we add the 'regs' parameter value
- */
-asmlinkage long _sys_clone(unsigned long clone_flags, unsigned long newsp,
-                           int __user *parent_tid, int __user *child_tid,
-                           struct pt_regs *regs)
-{
-        long ret;
-        /* FIXME: Is alignment necessary? */
-        /* newsp = ALIGN(newsp, 4); */
-        if (!newsp)
-                newsp = regs->sp;
-        ret = do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
-        return ret;
-}
-asmlinkage int _sys_fork(struct pt_regs *regs)
-{
-#ifdef CONFIG_MMU
-        return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
-#else
-        return -EINVAL;
-#endif
-}
diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index 11def45b98c5..e688a2be30f6 100644
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -22,6 +22,9 @@ config PARISC
        select GENERIC_STRNCPY_FROM_USER
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
+        select CLONE_BACKWARDS
        help
          The PA-RISC microprocessor is designed by Hewlett-Packard and used
diff --git a/arch/parisc/include/asm/processor.h b/arch/parisc/include/asm/processor.h
index 0e8b7b8ce8a2..09b54a57a48d 100644
--- a/arch/parisc/include/asm/processor.h
+++ b/arch/parisc/include/asm/processor.h
@@ -326,7 +326,6 @@ struct mm_struct;
 /* Free all resources held by a thread. */
 extern void release_thread(struct task_struct *);
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 extern void map_hpux_gateway_page(struct task_struct *tsk, struct mm_struct *mm);
diff --git a/arch/parisc/include/asm/signal.h b/arch/parisc/include/asm/signal.h
index 21abf4fc169a..0fdb3c835952 100644
--- a/arch/parisc/include/asm/signal.h
+++ b/arch/parisc/include/asm/signal.h
@@ -34,8 +34,6 @@ struct k_sigaction {
        struct sigaction sa;
 };
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #include <asm/sigcontext.h>
 #endif /* !__ASSEMBLY */
diff --git a/arch/parisc/include/asm/unistd.h b/arch/parisc/include/asm/unistd.h
index 541639c3f607..1efef41659c9 100644
--- a/arch/parisc/include/asm/unistd.h
+++ b/arch/parisc/include/asm/unistd.h
@@ -163,6 +163,10 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)	\
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 #endif /* __ASSEMBLY__ */
diff --git a/arch/parisc/kernel/entry.S b/arch/parisc/kernel/entry.S
index 18670a078849..bfb44247d7a7 100644
--- a/arch/parisc/kernel/entry.S
+++ b/arch/parisc/kernel/entry.S
@@ -708,59 +708,9 @@ ENTRY(end_fault_vector)
        .import         do_cpu_irq_mask,code
        /*
-         * r26 = function to be called
-         * r25 = argument to pass in
-         * r24 = flags for do_fork()
-         *
-         * Kernel threads don't ever return, so they don't need
-         * a true register context. We just save away the arguments
-         * for copy_thread/ret_ to properly set up the child.
-         */
-#define CLONE_VM 0x100  /* Must agree with <linux/sched.h> */
-#define CLONE_UNTRACED 0x00800000
-        .import do_fork
-ENTRY(__kernel_thread)
-        STREG   %r2, -RP_OFFSET(%r30)
-        copy    %r30, %r1
-        ldo     PT_SZ_ALGN(%r30),%r30
-#ifdef CONFIG_64BIT
-        /* Yo, function pointers in wide mode are little structs... -PB */
-        ldd     24(%r26), %r2
-        STREG   %r2, PT_GR27(%r1)       /* Store childs %dp */
-        ldd     16(%r26), %r26
-        STREG   %r22, PT_GR22(%r1)      /* save r22 (arg5) */
-        copy    %r0, %r22               /* user_tid */
-#endif
-        STREG   %r26, PT_GR26(%r1)  /* Store function & argument for child */
-        STREG   %r25, PT_GR25(%r1)
-        ldil    L%CLONE_UNTRACED, %r26
-        ldo     CLONE_VM(%r26), %r26   /* Force CLONE_VM since only init_mm */
-        or      %r26, %r24, %r26      /* will have kernel mappings.      */
-        ldi     1, %r25                 /* stack_start, signals kernel thread */
-        stw     %r0, -52(%r30)          /* user_tid */
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        BL      do_fork, %r2
-        copy    %r1, %r24               /* pt_regs */
-        /* Parent Returns here */
-        LDREG   -PT_SZ_ALGN-RP_OFFSET(%r30), %r2
-        ldo     -PT_SZ_ALGN(%r30), %r30
-        bv      %r0(%r2)
-        nop
-ENDPROC(__kernel_thread)
-        /*
         * Child Returns here
         *
-         * copy_thread moved args from temp save area set up above
+         * copy_thread moved args into task save area.
-         * into task save area.
         */
 ENTRY(ret_from_kernel_thread)
@@ -769,51 +719,17 @@ ENTRY(ret_from_kernel_thread)
        BL      schedule_tail, %r2
        nop
-        LDREG   TI_TASK-THREAD_SZ_ALGN(%r30), %r1
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
        LDREG   TASK_PT_GR25(%r1), %r26
 #ifdef CONFIG_64BIT
        LDREG   TASK_PT_GR27(%r1), %r27
-        LDREG   TASK_PT_GR22(%r1), %r22
 #endif
        LDREG   TASK_PT_GR26(%r1), %r1
        ble     0(%sr7, %r1)
        copy    %r31, %r2
+        b       finish_child_return
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-        loadgp                          /* Thread could have been in a module */
-#endif
-#ifndef CONFIG_64BIT
-        b       sys_exit
-#else
-        load32  sys_exit, %r1
-        bv      %r0(%r1)
-#endif
-        ldi     0, %r26
-ENDPROC(ret_from_kernel_thread)
-        .import sys_execve, code
-ENTRY(__execve)
-        copy    %r2, %r15
-        copy    %r30, %r16
-        ldo     PT_SZ_ALGN(%r30), %r30
-        STREG   %r26, PT_GR26(%r16)
-        STREG   %r25, PT_GR25(%r16)
-        STREG   %r24, PT_GR24(%r16)
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        BL      sys_execve, %r2
-        copy    %r16, %r26
-        cmpib,=,n 0,%r28,intr_return    /* forward */
-        /* yes, this will trap and die. */
-        copy    %r15, %r2
-        copy    %r16, %r30
-        bv      %r0(%r2)
        nop
-ENDPROC(__execve)
+ENDPROC(ret_from_kernel_thread)
        /*
@@ -1772,151 +1688,36 @@ dtlb_fault:
        LDREG   PT_GR18(\regs),%r18
        .endm
-ENTRY(sys_fork_wrapper)
+        .macro  fork_like name
+ENTRY(sys_\name\()_wrapper)
        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
        ldo     TASK_REGS(%r1),%r1
        reg_save %r1
-        mfctl   %cr27, %r3
+        mfctl   %cr27, %r28
-        STREG   %r3, PT_CR27(%r1)
+        b       sys_\name
+        STREG   %r28, PT_CR27(%r1)
-        STREG   %r2,-RP_OFFSET(%r30)
+ENDPROC(sys_\name\()_wrapper)
-        ldo     FRAME_SIZE(%r30),%r30
+        .endm
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        /* These are call-clobbered registers and therefore
-           also syscall-clobbered (we hope). */
-        STREG   %r2,PT_GR19(%r1)        /* save for child */
-        STREG   %r30,PT_GR21(%r1)
-        LDREG   PT_GR30(%r1),%r25
-        copy    %r1,%r24
-        BL      sys_clone,%r2
-        ldi     SIGCHLD,%r26
-        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
-wrapper_exit:
-        ldo     -FRAME_SIZE(%r30),%r30          /* get the stackframe */
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
-        ldo     TASK_REGS(%r1),%r1       /* get pt regs */
-        LDREG   PT_CR27(%r1), %r3
-        mtctl   %r3, %cr27
-        reg_restore %r1
-        /* strace expects syscall # to be preserved in r20 */
+fork_like clone
-        ldi     __NR_fork,%r20
+fork_like fork
-        bv %r0(%r2)
+fork_like vfork
-        STREG   %r20,PT_GR20(%r1)
-ENDPROC(sys_fork_wrapper)
        /* Set the return value for the child */
 ENTRY(child_return)
        BL      schedule_tail, %r2
        nop
+finish_child_return:
+        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
+        ldo     TASK_REGS(%r1),%r1       /* get pt regs */
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE-FRAME_SIZE(%r30), %r1
+        LDREG   PT_CR27(%r1), %r3
-        LDREG   TASK_PT_GR19(%r1),%r2
+        mtctl   %r3, %cr27
-        b       wrapper_exit
+        reg_restore %r1
+        b       syscall_exit
        copy    %r0,%r28
 ENDPROC(child_return)
-ENTRY(sys_clone_wrapper)
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
-        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
-        reg_save %r1
-        mfctl   %cr27, %r3
-        STREG   %r3, PT_CR27(%r1)
-        STREG   %r2,-RP_OFFSET(%r30)
-        ldo     FRAME_SIZE(%r30),%r30
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        /* WARNING - Clobbers r19 and r21, userspace must save these! */
-        STREG   %r2,PT_GR19(%r1)        /* save for child */
-        STREG   %r30,PT_GR21(%r1)
-        BL      sys_clone,%r2
-        copy    %r1,%r24
-        b       wrapper_exit
-        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
-ENDPROC(sys_clone_wrapper)
-ENTRY(sys_vfork_wrapper)
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
-        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
-        reg_save %r1
-        mfctl   %cr27, %r3
-        STREG   %r3, PT_CR27(%r1)
-        STREG   %r2,-RP_OFFSET(%r30)
-        ldo     FRAME_SIZE(%r30),%r30
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        STREG   %r2,PT_GR19(%r1)        /* save for child */
-        STREG   %r30,PT_GR21(%r1)
-        BL      sys_vfork,%r2
-        copy    %r1,%r26
-        b       wrapper_exit
-        LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
-ENDPROC(sys_vfork_wrapper)
-        
-        .macro  execve_wrapper execve
-        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
-        ldo     TASK_REGS(%r1),%r1      /* get pt regs */
-        /*
-         * Do we need to save/restore r3-r18 here?
-         * I don't think so. why would new thread need old
-         * threads registers?
-         */
-        /* %arg0 - %arg3 are already saved for us. */
-        STREG %r2,-RP_OFFSET(%r30)
-        ldo FRAME_SIZE(%r30),%r30
-#ifdef CONFIG_64BIT
-        ldo     -16(%r30),%r29          /* Reference param save area */
-#endif
-        BL \execve,%r2
-        copy %r1,%arg0
-        ldo -FRAME_SIZE(%r30),%r30
-        LDREG -RP_OFFSET(%r30),%r2
-        /* If exec succeeded we need to load the args */
-        ldo -1024(%r0),%r1
-        cmpb,>>= %r28,%r1,error_\execve
-        copy %r2,%r19
-error_\execve:
-        bv %r0(%r19)
-        nop
-        .endm
-        .import sys_execve
-ENTRY(sys_execve_wrapper)
-        execve_wrapper sys_execve
-ENDPROC(sys_execve_wrapper)
-#ifdef CONFIG_64BIT
-        .import sys32_execve
-ENTRY(sys32_execve_wrapper)
-        execve_wrapper sys32_execve
-ENDPROC(sys32_execve_wrapper)
-#endif
 ENTRY(sys_rt_sigreturn_wrapper)
        LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r26
        ldo     TASK_REGS(%r26),%r26    /* get pt regs */
diff --git a/arch/parisc/kernel/process.c b/arch/parisc/kernel/process.c
index cbc37216bf90..d13507246c5d 100644
--- a/arch/parisc/kernel/process.c
+++ b/arch/parisc/kernel/process.c
@@ -52,6 +52,7 @@
 #include <asm/io.h>
 #include <asm/asm-offsets.h>
+#include <asm/assembly.h>
 #include <asm/pdc.h>
 #include <asm/pdc_chassis.h>
 #include <asm/pgalloc.h>
@@ -165,23 +166,6 @@ void (*pm_power_off)(void) = machine_power_off;
 EXPORT_SYMBOL(pm_power_off);
 /*
- * Create a kernel thread
- */
-extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
-pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        /*
-         * FIXME: Once we are sure we don't need any debug here,
-         *        kernel_thread can become a #define.
-         */
-        return __kernel_thread(fn, arg, flags);
-}
-EXPORT_SYMBOL(kernel_thread);
-/*
 * Free current thread data structures etc..
 */
 void exit_thread(void)
@@ -218,48 +202,11 @@ int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
        return 1;
 }
-/* Note that "fork()" is implemented in terms of clone, with
-   parameters (SIGCHLD, regs->gr[30], regs). */
-int
-sys_clone(unsigned long clone_flags, unsigned long usp,
-          struct pt_regs *regs)
-{
-        /* Arugments from userspace are:
-           r26 = Clone flags.
-           r25 = Child stack.
-           r24 = parent_tidptr.
-           r23 = Is the TLS storage descriptor 
-           r22 = child_tidptr 
-           
-           However, these last 3 args are only examined
-           if the proper flags are set. */
-        int __user *parent_tidptr = (int __user *)regs->gr[24];
-        int __user *child_tidptr  = (int __user *)regs->gr[22];
-        /* usp must be word aligned.  This also prevents users from
-         * passing in the value 1 (which is the signal for a special
-         * return for a kernel thread) */
-        usp = ALIGN(usp, 4);
-        /* A zero value for usp means use the current stack */
-        if (usp == 0)
-          usp = regs->gr[30];
-        return do_fork(clone_flags, usp, regs, 0, parent_tidptr, child_tidptr);
-}
-int
-sys_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
-}
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-            unsigned long unused,       /* in ia64 this is "user_stack_size" */
+            unsigned long arg, struct task_struct *p)
-            struct task_struct * p, struct pt_regs * pregs)
 {
-        struct pt_regs * cregs = &(p->thread.regs);
+        struct pt_regs *cregs = &(p->thread.regs);
        void *stack = task_stack_page(p);
        
        /* We have to use void * instead of a function pointer, because
@@ -270,48 +217,39 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
 #ifdef CONFIG_HPUX
        extern void * const hpux_child_return;
 #endif
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(cregs, 0, sizeof(struct pt_regs));
+                if (!usp) /* idle thread */
+                        return 0;
-        *cregs = *pregs;
-        /* Set the return value for the child.  Note that this is not
-           actually restored by the syscall exit path, but we put it
-           here for consistency in case of signals. */
-        cregs->gr[28] = 0; /* child */
-        /*
-         * We need to differentiate between a user fork and a
-         * kernel fork. We can't use user_mode, because the
-         * the syscall path doesn't save iaoq. Right now
-         * We rely on the fact that kernel_thread passes
-         * in zero for usp.
-         */
-        if (usp == 1) {
                /* kernel thread */
-                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN;
                /* Must exit via ret_from_kernel_thread in order
                 * to call schedule_tail()
                 */
+                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
                cregs->kpc = (unsigned long) &ret_from_kernel_thread;
                /*
                 * Copy function and argument to be called from
                 * ret_from_kernel_thread.
                 */
 #ifdef CONFIG_64BIT
-                cregs->gr[27] = pregs->gr[27];
+                cregs->gr[27] = ((unsigned long *)usp)[3];
+                cregs->gr[26] = ((unsigned long *)usp)[2];
+#else
+                cregs->gr[26] = usp;
 #endif
-                cregs->gr[26] = pregs->gr[26];
+                cregs->gr[25] = arg;
-                cregs->gr[25] = pregs->gr[25];
        } else {
                /* user thread */
-                /*
+                /* usp must be word aligned.  This also prevents users from
-                 * Note that the fork wrappers are responsible
+                 * passing in the value 1 (which is the signal for a special
-                 * for setting gr[21].
+                 * return for a kernel thread) */
-                 */
+                if (usp) {
+                        usp = ALIGN(usp, 4);
-                /* Use same stack depth as parent */
+                        if (likely(usp))
-                cregs->ksp = (unsigned long)stack
+                                cregs->gr[30] = usp;
-                        + (pregs->gr[21] & (THREAD_SIZE - 1));
+                }
-                cregs->gr[30] = usp;
+                cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
                if (personality(p->personality) == PER_HPUX) {
 #ifdef CONFIG_HPUX
                        cregs->kpc = (unsigned long) &hpux_child_return;
@@ -323,8 +261,7 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
                }
                /* Setup thread TLS area from the 4th parameter in clone */
                if (clone_flags & CLONE_SETTLS)
-                  cregs->cr27 = pregs->gr[23];
+                        cregs->cr27 = cregs->gr[23];
-        
        }
        return 0;
@@ -335,39 +272,6 @@ unsigned long thread_saved_pc(struct task_struct *t)
        return t->thread.regs.kpc;
 }
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname((const char __user *) regs->gr[26]);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name,
-                          (const char __user *const __user *) regs->gr[25],
-                          (const char __user *const __user *) regs->gr[24],
-                          regs);
-        putname(filename);
-out:
-        return error;
-}
-extern int __execve(const char *filename,
-                    const char *const argv[],
-                    const char *const envp[], struct task_struct *task);
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        return __execve(filename, argv, envp, current);
-}
 unsigned long
 get_wchan(struct task_struct *p)
 {
diff --git a/arch/parisc/kernel/sys_parisc32.c b/arch/parisc/kernel/sys_parisc32.c
index bf5b93a885d3..9cfdaa19ab63 100644
--- a/arch/parisc/kernel/sys_parisc32.c
+++ b/arch/parisc/kernel/sys_parisc32.c
@@ -53,28 +53,6 @@
 #define DBG(x)
 #endif
-/*
- * sys32_execve() executes a new program.
- */
-asmlinkage int sys32_execve(struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        DBG(("sys32_execve(%p) r26 = 0x%lx\n", regs, regs->gr[26]));
-        filename = getname((const char __user *) regs->gr[26]);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = compat_do_execve(filename->name, compat_ptr(regs->gr[25]),
-                                 compat_ptr(regs->gr[24]), regs);
-        putname(filename);
-out:
-        return error;
-}
 asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23,
        int r22, int r21, int r20)
 {
diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S
index cbf5d59d5d6a..54d950b067b7 100644
--- a/arch/parisc/kernel/syscall_table.S
+++ b/arch/parisc/kernel/syscall_table.S
@@ -66,7 +66,7 @@
        ENTRY_SAME(creat)
        ENTRY_SAME(link)
        ENTRY_SAME(unlink)              /* 10 */
-        ENTRY_DIFF(execve_wrapper)
+        ENTRY_COMP(execve)
        ENTRY_SAME(chdir)
        /* See comments in kernel/time.c!!! Maybe we don't need this? */
        ENTRY_COMP(time)
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index a902a5c1c76a..951a517a1a0f 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -144,6 +144,8 @@ config PPC
        select GENERIC_KERNEL_THREAD
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_EXECVE
+        select CLONE_BACKWARDS
 config EARLY_PRINTK
        bool
diff --git a/arch/powerpc/include/asm/signal.h b/arch/powerpc/include/asm/signal.h
index 189998bb61c4..a101637725a2 100644
--- a/arch/powerpc/include/asm/signal.h
+++ b/arch/powerpc/include/asm/signal.h
@@ -3,6 +3,4 @@
 #include <uapi/asm/signal.h>
-struct pt_regs;
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* _ASM_POWERPC_SIGNAL_H */
diff --git a/arch/powerpc/include/asm/syscalls.h b/arch/powerpc/include/asm/syscalls.h
index 329db4ec12ca..b5308d3e6d39 100644
--- a/arch/powerpc/include/asm/syscalls.h
+++ b/arch/powerpc/include/asm/syscalls.h
@@ -17,15 +17,6 @@ asmlinkage unsigned long sys_mmap(unsigned long addr, size_t len,
 asmlinkage unsigned long sys_mmap2(unsigned long addr, size_t len,
                unsigned long prot, unsigned long flags,
                unsigned long fd, unsigned long pgoff);
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long usp,
-                int __user *parent_tidp, void __user *child_threadptr,
-                int __user *child_tidp, int p6, struct pt_regs *regs);
-asmlinkage int sys_fork(unsigned long p1, unsigned long p2,
-                unsigned long p3, unsigned long p4, unsigned long p5,
-                unsigned long p6, struct pt_regs *regs);
-asmlinkage int sys_vfork(unsigned long p1, unsigned long p2,
-                unsigned long p3, unsigned long p4, unsigned long p5,
-                unsigned long p6, struct pt_regs *regs);
 asmlinkage long sys_pipe(int __user *fildes);
 asmlinkage long sys_pipe2(int __user *fildes, int flags);
 asmlinkage long sys_rt_sigaction(int sig,
diff --git a/arch/powerpc/include/asm/unistd.h b/arch/powerpc/include/asm/unistd.h
index 921dce6d8445..76fe846ec40e 100644
--- a/arch/powerpc/include/asm/unistd.h
+++ b/arch/powerpc/include/asm/unistd.h
@@ -56,7 +56,9 @@
 #define __ARCH_WANT_COMPAT_SYS_SENDFILE
 #endif
 #define __ARCH_WANT_SYS_EXECVE
-#define __ARCH_WANT_KERNEL_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
index 9499385676e7..d22e73e4618b 100644
--- a/arch/powerpc/kernel/entry_32.S
+++ b/arch/powerpc/kernel/entry_32.S
@@ -444,11 +444,6 @@ ret_from_kernel_thread:
        PPC440EP_ERR42
        blrl
        li      r3,0
-        b       do_exit         # no return
-        .globl  __ret_from_kernel_execve
-__ret_from_kernel_execve:
-        addi    r1,r3,-STACK_FRAME_OVERHEAD
        b       ret_from_syscall
 /* Traced system call support */
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 56e0ff0878b5..e9a906c27234 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -373,17 +373,11 @@ _GLOBAL(ret_from_fork)
 _GLOBAL(ret_from_kernel_thread)
        bl      .schedule_tail
        REST_NVGPRS(r1)
-        REST_GPR(2,r1)
+        ld      r14, 0(r14)
        mtlr    r14
        mr      r3,r15
        blrl
        li      r3,0
-        b       .do_exit        # no return
-_GLOBAL(__ret_from_kernel_execve)
-        addi    r1,r3,-STACK_FRAME_OVERHEAD
-        li      r10,1
-        std     r10,SOFTE(r1)
        b       syscall_exit
        .section        ".toc","aw"
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index ba48233500f6..81430674e71c 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -733,8 +733,7 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 extern unsigned long dscr_default; /* defined in arch/powerpc/kernel/sysfs.c */
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long arg, struct task_struct *p,
+                unsigned long arg, struct task_struct *p)
-                struct pt_regs *regs)
 {
        struct pt_regs *childregs, *kregs;
        extern void ret_from_fork(void);
@@ -745,25 +744,25 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        /* Copy registers */
        sp -= sizeof(struct pt_regs);
        childregs = (struct pt_regs *) sp;
-        if (!regs) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
-                /* for kernel thread, set `current' and stackptr in new task */
+                struct thread_info *ti = (void *)task_stack_page(p);
                memset(childregs, 0, sizeof(struct pt_regs));
                childregs->gpr[1] = sp + sizeof(struct pt_regs);
+                childregs->gpr[14] = usp;       /* function */
 #ifdef CONFIG_PPC64
-                childregs->gpr[14] = *(unsigned long *)usp;
-                childregs->gpr[2] = ((unsigned long *)usp)[1],
                clear_tsk_thread_flag(p, TIF_32BIT);
-#else
+                childregs->softe = 1;
-                childregs->gpr[14] = usp;       /* function */
-                childregs->gpr[2] = (unsigned long) p;
 #endif
                childregs->gpr[15] = arg;
                p->thread.regs = NULL;  /* no user register state */
+                ti->flags |= _TIF_RESTOREALL;
                f = ret_from_kernel_thread;
        } else {
+                struct pt_regs *regs = current_pt_regs();
                CHECK_FULL_REGS(regs);
                *childregs = *regs;
-                childregs->gpr[1] = usp;
+                if (usp)
+                        childregs->gpr[1] = usp;
                p->thread.regs = childregs;
                childregs->gpr[3] = 0;  /* Result from fork() */
                if (clone_flags & CLONE_SETTLS) {
@@ -1027,51 +1026,6 @@ int get_unalign_ctl(struct task_struct *tsk, unsigned long adr)
        return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr);
 }
-#define TRUNC_PTR(x)    ((typeof(x))(((unsigned long)(x)) & 0xffffffff))
-int sys_clone(unsigned long clone_flags, unsigned long usp,
-              int __user *parent_tidp, void __user *child_threadptr,
-              int __user *child_tidp, int p6,
-              struct pt_regs *regs)
-{
-        CHECK_FULL_REGS(regs);
-        if (usp == 0)
-                usp = regs->gpr[1];     /* stack pointer for child */
-#ifdef CONFIG_PPC64
-        if (is_32bit_task()) {
-                parent_tidp = TRUNC_PTR(parent_tidp);
-                child_tidp = TRUNC_PTR(child_tidp);
-        }
-#endif
-        return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp);
-}
-int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3,
-             unsigned long p4, unsigned long p5, unsigned long p6,
-             struct pt_regs *regs)
-{
-        CHECK_FULL_REGS(regs);
-        return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL);
-}
-int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3,
-              unsigned long p4, unsigned long p5, unsigned long p6,
-              struct pt_regs *regs)
-{
-        CHECK_FULL_REGS(regs);
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1],
-                        regs, 0, NULL, NULL);
-}
-void __ret_from_kernel_execve(struct pt_regs *normal)
-__noreturn;
-void ret_from_kernel_execve(struct pt_regs *normal)
-{
-        set_thread_flag(TIF_RESTOREALL);
-        __ret_from_kernel_execve(normal);
-}
 static inline int valid_irq_stack(unsigned long sp, struct task_struct *p,
                                  unsigned long nbytes)
 {
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index d385f396dfee..3cbb8757704e 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -138,8 +138,10 @@ config S390
        select KTIME_SCALAR if 32BIT
        select HAVE_ARCH_SECCOMP_FILTER
        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_RELA
+        select CLONE_BACKWARDS2
 config SCHED_OMIT_FRAME_POINTER
        def_bool y
diff --git a/arch/s390/include/asm/signal.h b/arch/s390/include/asm/signal.h
index bffdbdd5b3d7..db7ddfaf5b79 100644
--- a/arch/s390/include/asm/signal.h
+++ b/arch/s390/include/asm/signal.h
@@ -39,6 +39,4 @@ struct k_sigaction {
        struct sigaction sa;
 };
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif
diff --git a/arch/s390/include/asm/unistd.h b/arch/s390/include/asm/unistd.h
index bbbae41fa9a5..086bb8eaf6ab 100644
--- a/arch/s390/include/asm/unistd.h
+++ b/arch/s390/include/asm/unistd.h
@@ -54,7 +54,9 @@
 #   define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 # endif
 #define __ARCH_WANT_SYS_EXECVE
-#define __ARCH_WANT_KERNEL_EXECVE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
+#define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index ef46f66bc0d6..aa8f2ba6289b 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -330,40 +330,18 @@ ENTRY(ret_from_fork)
        la      %r11,STACK_FRAME_OVERHEAD(%r15)
        l       %r12,__LC_THREAD_INFO
        l       %r13,__LC_SVC_NEW_PSW+4
-        tm      __PT_PSW+1(%r11),0x01   # forking a kernel thread ?
-        je      1f
        l       %r1,BASED(.Lschedule_tail)
        basr    %r14,%r1                # call schedule_tail
        TRACE_IRQS_ON
        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        j       sysc_tracenogo
+        tm      __PT_PSW+1(%r11),0x01   # forking a kernel thread ?
+        jne     sysc_tracenogo
-1:      # it's a kernel thread
+        # it's a kernel thread
-        st      %r15,__PT_R15(%r11)     # store stack pointer for new kthread
+        lm      %r9,%r10,__PT_R9(%r11)  # load gprs
-        l       %r1,BASED(.Lschedule_tail)
-        basr    %r14,%r1                # call schedule_tail
-        TRACE_IRQS_ON
-        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        lm      %r9,%r11,__PT_R9(%r11)  # load gprs
 ENTRY(kernel_thread_starter)
        la      %r2,0(%r10)
        basr    %r14,%r9
-        la      %r2,0
+        j       sysc_tracenogo
-        br      %r11                    # do_exit
-#
-# kernel_execve function needs to deal with pt_regs that is not
-# at the usual place
-#
-ENTRY(ret_from_kernel_execve)
-        ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
-        lr      %r15,%r2
-        lr      %r11,%r2
-        ahi     %r15,-STACK_FRAME_OVERHEAD
-        xc      __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
-        l       %r12,__LC_THREAD_INFO
-        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        j       sysc_return
 /*
 * Program check handler routine
diff --git a/arch/s390/kernel/entry.h b/arch/s390/kernel/entry.h
index d0d3f69a7346..d8251b98f17a 100644
--- a/arch/s390/kernel/entry.h
+++ b/arch/s390/kernel/entry.h
@@ -54,10 +54,6 @@ long sys_s390_fadvise64(int fd, u32 offset_high, u32 offset_low,
 long sys_s390_fadvise64_64(struct fadvise64_64_args __user *args);
 long sys_s390_fallocate(int fd, int mode, loff_t offset, u32 len_high,
                        u32 len_low);
-long sys_fork(void);
-long sys_clone(unsigned long newsp, unsigned long clone_flags,
-               int __user *parent_tidptr, int __user *child_tidptr);
-long sys_vfork(void);
 long sys_sigsuspend(int history0, int history1, old_sigset_t mask);
 long sys_sigaction(int sig, const struct old_sigaction __user *act,
                   struct old_sigaction __user *oact);
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 07d8de353984..499e95e90f38 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -352,33 +352,17 @@ sysc_tracenogo:
 ENTRY(ret_from_fork)
        la      %r11,STACK_FRAME_OVERHEAD(%r15)
        lg      %r12,__LC_THREAD_INFO
-        tm      __PT_PSW+1(%r11),0x01   # forking a kernel thread ?
-        je      1f
        brasl   %r14,schedule_tail
        TRACE_IRQS_ON
        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        j       sysc_tracenogo
+        tm      __PT_PSW+1(%r11),0x01   # forking a kernel thread ?
-1:      # it's a kernel thread
+        jne     sysc_tracenogo
-        stg     %r15,__PT_R15(%r11)     # store stack pointer for new kthread
+        # it's a kernel thread
-        brasl   %r14,schedule_tail
+        lmg     %r9,%r10,__PT_R9(%r11)  # load gprs
-        TRACE_IRQS_ON
-        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        lmg     %r9,%r11,__PT_R9(%r11)  # load gprs
 ENTRY(kernel_thread_starter)
        la      %r2,0(%r10)
        basr    %r14,%r9
-        la      %r2,0
+        j       sysc_tracenogo
-        br      %r11                    # do_exit
-ENTRY(ret_from_kernel_execve)
-        ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
-        lgr     %r15,%r2
-        lgr     %r11,%r2
-        aghi    %r15,-STACK_FRAME_OVERHEAD
-        xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
-        lg      %r12,__LC_THREAD_INFO
-        ssm     __LC_SVC_NEW_PSW        # reenable interrupts
-        j       sysc_return
 /*
 * Program check handler routine
diff --git a/arch/s390/kernel/process.c b/arch/s390/kernel/process.c
index cd31ad457a9b..536d64579d9a 100644
--- a/arch/s390/kernel/process.c
+++ b/arch/s390/kernel/process.c
@@ -117,8 +117,7 @@ void release_thread(struct task_struct *dead_task)
 }
 int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
-                unsigned long arg,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct thread_info *ti;
        struct fake_frame
@@ -150,7 +149,7 @@ int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
        frame->sf.gprs[9] = (unsigned long) frame;
        /* Store access registers to kernel stack of new process. */
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* kernel thread */
                memset(&frame->childregs, 0, sizeof(struct pt_regs));
                frame->childregs.psw.mask = psw_kernel_bits | PSW_MASK_DAT |
@@ -164,9 +163,10 @@ int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
                return 0;
        }
-        frame->childregs = *regs;
+        frame->childregs = *current_pt_regs();
        frame->childregs.gprs[2] = 0;   /* child returns 0 on fork. */
-        frame->childregs.gprs[15] = new_stackp;
+        if (new_stackp)
+                frame->childregs.gprs[15] = new_stackp;
        /* Don't copy runtime instrumentation info */
        p->thread.ri_cb = NULL;
@@ -183,57 +183,24 @@ int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
               sizeof(s390_fp_regs));
        /* Set a new TLS ?  */
        if (clone_flags & CLONE_SETTLS)
-                p->thread.acrs[0] = regs->gprs[6];
+                p->thread.acrs[0] = frame->childregs.gprs[6];
 #else /* CONFIG_64BIT */
        /* Save the fpu registers to new thread structure. */
        save_fp_regs(&p->thread.fp_regs);
        /* Set a new TLS ?  */
        if (clone_flags & CLONE_SETTLS) {
+                unsigned long tls = frame->childregs.gprs[6];
                if (is_compat_task()) {
-                        p->thread.acrs[0] = (unsigned int) regs->gprs[6];
+                        p->thread.acrs[0] = (unsigned int)tls;
                } else {
-                        p->thread.acrs[0] = (unsigned int)(regs->gprs[6] >> 32);
+                        p->thread.acrs[0] = (unsigned int)(tls >> 32);
-                        p->thread.acrs[1] = (unsigned int) regs->gprs[6];
+                        p->thread.acrs[1] = (unsigned int)tls;
                }
        }
 #endif /* CONFIG_64BIT */
        return 0;
 }
-SYSCALL_DEFINE0(fork)
-{
-        struct pt_regs *regs = task_pt_regs(current);
-        return do_fork(SIGCHLD, regs->gprs[15], regs, 0, NULL, NULL);
-}
-SYSCALL_DEFINE4(clone, unsigned long, newsp, unsigned long, clone_flags,
-                int __user *, parent_tidptr, int __user *, child_tidptr)
-{
-        struct pt_regs *regs = task_pt_regs(current);
-        if (!newsp)
-                newsp = regs->gprs[15];
-        return do_fork(clone_flags, newsp, regs, 0,
-                       parent_tidptr, child_tidptr);
-}
-/*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
-SYSCALL_DEFINE0(vfork)
-{
-        struct pt_regs *regs = task_pt_regs(current);
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
-                       regs->gprs[15], regs, 0, NULL, NULL);
-}
 asmlinkage void execve_tail(void)
 {
        current->thread.fp_regs.fpc = 0;
diff --git a/arch/score/Kconfig b/arch/score/Kconfig
index 4f93a431a45a..45893390c7dd 100644
--- a/arch/score/Kconfig
+++ b/arch/score/Kconfig
@@ -13,6 +13,9 @@ config SCORE
       select GENERIC_CLOCKEVENTS
       select HAVE_MOD_ARCH_SPECIFIC
        select MODULES_USE_ELF_REL
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
+        select CLONE_BACKWARDS
 choice
        prompt "System type"
diff --git a/arch/score/include/asm/processor.h b/arch/score/include/asm/processor.h
index ab3aceb54209..d9a922d8711b 100644
--- a/arch/score/include/asm/processor.h
+++ b/arch/score/include/asm/processor.h
@@ -13,7 +13,6 @@ struct task_struct;
 */
 extern void (*cpu_wait)(void);
-extern long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 extern unsigned long thread_saved_pc(struct task_struct *tsk);
 extern void start_thread(struct pt_regs *regs,
                        unsigned long pc, unsigned long sp);
diff --git a/arch/score/include/asm/syscalls.h b/arch/score/include/asm/syscalls.h
index 1dd5e0d6b0c3..acaeed680956 100644
--- a/arch/score/include/asm/syscalls.h
+++ b/arch/score/include/asm/syscalls.h
@@ -1,8 +1,6 @@
 #ifndef _ASM_SCORE_SYSCALLS_H
 #define _ASM_SCORE_SYSCALLS_H
-asmlinkage long score_clone(struct pt_regs *regs);
-asmlinkage long score_execve(struct pt_regs *regs);
 asmlinkage long score_sigaltstack(struct pt_regs *regs);
 asmlinkage long score_rt_sigreturn(struct pt_regs *regs);
diff --git a/arch/score/include/asm/unistd.h b/arch/score/include/asm/unistd.h
index a862384e9c16..56001c93095a 100644
--- a/arch/score/include/asm/unistd.h
+++ b/arch/score/include/asm/unistd.h
@@ -4,5 +4,9 @@
 #define __ARCH_WANT_SYSCALL_NO_FLAGS
 #define __ARCH_WANT_SYSCALL_OFF_T
 #define __ARCH_WANT_SYSCALL_DEPRECATED
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
+#define __ARCH_WANT_SYS_FORK
+#define __ARCH_WANT_SYS_VFORK
 #include <asm-generic/unistd.h>
diff --git a/arch/score/kernel/entry.S b/arch/score/kernel/entry.S
index 83bb96079c43..1557ca1a2951 100644
--- a/arch/score/kernel/entry.S
+++ b/arch/score/kernel/entry.S
@@ -278,6 +278,13 @@ need_resched:
        nop
 #endif
+ENTRY(ret_from_kernel_thread)
+        bl      schedule_tail                   # r4=struct task_struct *prev
+        nop
+        mv      r4, r13
+        brl     r12
+        j       syscall_exit
 ENTRY(ret_from_fork)
        bl      schedule_tail                   # r4=struct task_struct *prev
@@ -480,16 +487,6 @@ illegal_syscall:
        sw      r9, [r0, PT_R7]
        j       syscall_return
-ENTRY(sys_execve)
-        mv      r4, r0
-        la      r8, score_execve
-        br      r8
-ENTRY(sys_clone)
-        mv      r4, r0
-        la      r8, score_clone
-        br      r8
 ENTRY(sys_rt_sigreturn)
        mv      r4, r0
        la      r8, score_rt_sigreturn
@@ -499,16 +496,3 @@ ENTRY(sys_sigaltstack)
        mv      r4, r0
        la      r8, score_sigaltstack
        br      r8
-#ifdef __ARCH_WANT_SYSCALL_DEPRECATED
-ENTRY(sys_fork)
-        mv      r4, r0
-        la      r8, score_fork
-        br      r8
-ENTRY(sys_vfork)
-        mv      r4, r0
-        la      r8, score_vfork
-        br      r8
-#endif /* __ARCH_WANT_SYSCALL_DEPRECATED */
diff --git a/arch/score/kernel/process.c b/arch/score/kernel/process.c
index 637970cfd3f4..79568466b578 100644
--- a/arch/score/kernel/process.c
+++ b/arch/score/kernel/process.c
@@ -60,6 +60,7 @@ void __noreturn cpu_idle(void)
 }
 void ret_from_fork(void);
+void ret_from_kernel_thread(void);
 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
 {
@@ -86,29 +87,27 @@ void flush_thread(void) {}
 * set up the kernel stack and exception frames for a new process
 */
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct thread_info *ti = task_thread_info(p);
        struct pt_regs *childregs = task_pt_regs(p);
+        struct pt_regs *regs = current_pt_regs();
-        p->set_child_tid = NULL;
+        p->thread.reg0 = (unsigned long) childregs;
-        p->clear_child_tid = NULL;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
-        *childregs = *regs;
+                p->thread->reg12 = usp;
-        childregs->regs[7] = 0;         /* Clear error flag */
+                p->thread->reg13 = arg;
-        childregs->regs[4] = 0;         /* Child gets zero as return value */
+                p->thread.reg3 = (unsigned long) ret_from_kernel_thread;
-        regs->regs[4] = p->pid;
-        if (childregs->cp0_psr & 0x8) { /* test kernel fork or user fork */
-                childregs->regs[0] = usp;               /* user fork */
        } else {
-                childregs->regs[28] = (unsigned long) ti; /* kernel fork */
+                *childregs = *current_pt_regs();
-                childregs->regs[0] = (unsigned long) childregs;
+                childregs->regs[7] = 0;         /* Clear error flag */
+                childregs->regs[4] = 0;         /* Child gets zero as return value */
+                if (usp)
+                        childregs->regs[0] = usp;       /* user fork */
+                p->thread.reg3 = (unsigned long) ret_from_fork;
        }
-        p->thread.reg0 = (unsigned long) childregs;
-        p->thread.reg3 = (unsigned long) ret_from_fork;
        p->thread.cp0_psr = 0;
        return 0;
@@ -120,32 +119,6 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
        return 1;
 }
-static void __noreturn
-kernel_thread_helper(void *unused0, int (*fn)(void *),
-                 void *arg, void *unused1)
-{
-        do_exit(fn(arg));
-}
-/*
- * Create a kernel thread.
- */
-long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.regs[6] = (unsigned long) arg;
-        regs.regs[5] = (unsigned long) fn;
-        regs.cp0_epc = (unsigned long) kernel_thread_helper;
-        regs.cp0_psr = (regs.cp0_psr & ~(0x1|0x4|0x8)) | \
-                        ((regs.cp0_psr & 0x3) << 2);
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, \
-                        0, &regs, 0, NULL, NULL);
-}
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
        return task_pt_regs(tsk)->cp0_epc;
diff --git a/arch/score/kernel/sys_score.c b/arch/score/kernel/sys_score.c
index d45cf00a3351..47c20ba46167 100644
--- a/arch/score/kernel/sys_score.c
+++ b/arch/score/kernel/sys_score.c
@@ -48,92 +48,3 @@ sys_mmap(unsigned long addr, unsigned long len, unsigned long prot,
                return -EINVAL;
        return sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
 }
-asmlinkage long
-score_fork(struct pt_regs *regs)
-{
-        return do_fork(SIGCHLD, regs->regs[0], regs, 0, NULL, NULL);
-}
-/*
- * Clone a task - this clones the calling program thread.
- * This is called indirectly via a small wrapper
- */
-asmlinkage long
-score_clone(struct pt_regs *regs)
-{
-        unsigned long clone_flags;
-        unsigned long newsp;
-        int __user *parent_tidptr, *child_tidptr;
-        clone_flags = regs->regs[4];
-        newsp = regs->regs[5];
-        if (!newsp)
-                newsp = regs->regs[0];
-        parent_tidptr = (int __user *)regs->regs[6];
-        child_tidptr = (int __user *)regs->regs[8];
-        return do_fork(clone_flags, newsp, regs, 0,
-                        parent_tidptr, child_tidptr);
-}
-asmlinkage long
-score_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
-                        regs->regs[0], regs, 0, NULL, NULL);
-}
-/*
- * sys_execve() executes a new program.
- * This is called indirectly via a small wrapper
- */
-asmlinkage long
-score_execve(struct pt_regs *regs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname((char __user*)regs->regs[4]);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                return error;
-        error = do_execve(filename->name,
-                          (const char __user *const __user *)regs->regs[5],
-                          (const char __user *const __user *)regs->regs[6],
-                          regs);
-        putname(filename);
-        return error;
-}
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-asmlinkage
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register unsigned long __r4 asm("r4") = (unsigned long) filename;
-        register unsigned long __r5 asm("r5") = (unsigned long) argv;
-        register unsigned long __r6 asm("r6") = (unsigned long) envp;
-        register unsigned long __r7 asm("r7");
-        __asm__ __volatile__ (" \n"
-                "ldi    r27, %5         \n"
-                "syscall                \n"
-                "mv     %0, r4          \n"
-                "mv     %1, r7          \n"
-                : "=&r" (__r4), "=r" (__r7)
-                : "r" (__r4), "r" (__r5), "r" (__r6), "i" (__NR_execve)
-                : "r8", "r9", "r10", "r11", "r22", "r23", "r24", "r25",
-                  "r26", "r27", "memory");
-        if (__r7 == 0)
-                return __r4;
-        return -__r4;
-}
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index babc2b826c5c..8451317eed58 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -40,6 +40,8 @@ config SUPERH
        select GENERIC_STRNLEN_USER
        select HAVE_MOD_ARCH_SPECIFIC if DWARF_UNWINDER
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
        help
          The SuperH is a RISC processor targeted for use in embedded systems
          and consumer electronics; it was also used in the Sega Dreamcast
diff --git a/arch/sh/include/asm/processor_32.h b/arch/sh/include/asm/processor_32.h
index b6311fd2d066..b1320d55ca30 100644
--- a/arch/sh/include/asm/processor_32.h
+++ b/arch/sh/include/asm/processor_32.h
@@ -126,11 +126,6 @@ extern void start_thread(struct pt_regs *regs, unsigned long new_pc, unsigned lo
 /* Free all resources held by a thread. */
 extern void release_thread(struct task_struct *);
-/*
- * create a kernel thread without removing it from tasklists
- */
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 /* Copy and release all segment info associated with a VM */
 #define copy_segments(p, mm)    do { } while(0)
 #define release_segments(mm)    do { } while(0)
diff --git a/arch/sh/include/asm/processor_64.h b/arch/sh/include/asm/processor_64.h
index cd6029fb2c01..1ee8946f0952 100644
--- a/arch/sh/include/asm/processor_64.h
+++ b/arch/sh/include/asm/processor_64.h
@@ -159,11 +159,6 @@ struct mm_struct;
 /* Free all resources held by a thread. */
 extern void release_thread(struct task_struct *);
-/*
- * create a kernel thread without removing it from tasklists
- */
-extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 /* Copy and release all segment info associated with a VM */
 #define copy_segments(p, mm)    do { } while (0)
diff --git a/arch/sh/include/asm/syscalls_32.h b/arch/sh/include/asm/syscalls_32.h
index 6c1fa559753c..cc25485996bb 100644
--- a/arch/sh/include/asm/syscalls_32.h
+++ b/arch/sh/include/asm/syscalls_32.h
@@ -9,20 +9,6 @@
 struct pt_regs;
-asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
-                        unsigned long r6, unsigned long r7,
-                        struct pt_regs __regs);
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long parent_tidptr,
-                         unsigned long child_tidptr,
-                         struct pt_regs __regs);
-asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs __regs);
-asmlinkage int sys_execve(const char __user *ufilename,
-                          const char __user *const __user *uargv,
-                          const char __user *const __user *uenvp,
-                          unsigned long r7, struct pt_regs __regs);
 asmlinkage int sys_sigsuspend(old_sigset_t mask);
 asmlinkage int sys_sigaction(int sig, const struct old_sigaction __user *act,
                             struct old_sigaction __user *oact);
diff --git a/arch/sh/include/asm/syscalls_64.h b/arch/sh/include/asm/syscalls_64.h
index ee519f41d950..d62e8eb22f74 100644
--- a/arch/sh/include/asm/syscalls_64.h
+++ b/arch/sh/include/asm/syscalls_64.h
@@ -9,23 +9,6 @@
 struct pt_regs;
-asmlinkage int sys_fork(unsigned long r2, unsigned long r3,
-                        unsigned long r4, unsigned long r5,
-                        unsigned long r6, unsigned long r7,
-                        struct pt_regs *pregs);
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs *pregs);
-asmlinkage int sys_vfork(unsigned long r2, unsigned long r3,
-                         unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs *pregs);
-asmlinkage int sys_execve(const char *ufilename, char **uargv,
-                          char **uenvp, unsigned long r5,
-                          unsigned long r6, unsigned long r7,
-                          struct pt_regs *pregs);
 /* Misc syscall related bits */
 asmlinkage long long do_syscall_trace_enter(struct pt_regs *regs);
 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs);
diff --git a/arch/sh/include/asm/unistd.h b/arch/sh/include/asm/unistd.h
index 38956dfa76f7..43d3f26b2eab 100644
--- a/arch/sh/include/asm/unistd.h
+++ b/arch/sh/include/asm/unistd.h
@@ -28,6 +28,10 @@
 # define __ARCH_WANT_SYS_SIGPENDING
 # define __ARCH_WANT_SYS_SIGPROCMASK
 # define __ARCH_WANT_SYS_RT_SIGACTION
+# define __ARCH_WANT_SYS_EXECVE
+# define __ARCH_WANT_SYS_FORK
+# define __ARCH_WANT_SYS_VFORK
+# define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/sh/kernel/Makefile b/arch/sh/kernel/Makefile
index 88571ff8eeec..f259b37874e9 100644
--- a/arch/sh/kernel/Makefile
+++ b/arch/sh/kernel/Makefile
@@ -16,7 +16,7 @@ obj-y	:= debugtraps.o dma-nommu.o dumpstack.o 		\
           machvec.o nmi_debug.o process.o                              \
           process_$(BITS).o ptrace.o ptrace_$(BITS).o                  \
           reboot.o return_address.o                                    \
-           setup.o signal_$(BITS).o sys_sh.o sys_sh$(BITS).o            \
+           setup.o signal_$(BITS).o sys_sh.o                            \
           syscalls_$(BITS).o time.o topology.o traps.o                 \
           traps_$(BITS).o unwinder.o
@@ -25,6 +25,7 @@ obj-y				+= iomap.o
 obj-$(CONFIG_HAS_IOPORT)        += ioport.o
 endif
+obj-$(CONFIG_SUPERH32)          += sys_sh32.o
 obj-y                           += cpu/
 obj-$(CONFIG_VSYSCALL)          += vsyscall/
 obj-$(CONFIG_SMP)               += smp.o
diff --git a/arch/sh/kernel/cpu/sh5/entry.S b/arch/sh/kernel/cpu/sh5/entry.S
index 7e605b95592a..0c8d0377d40b 100644
--- a/arch/sh/kernel/cpu/sh5/entry.S
+++ b/arch/sh/kernel/cpu/sh5/entry.S
@@ -1228,6 +1228,25 @@ ret_from_fork:
        pta     ret_from_syscall, tr0
        blink   tr0, ZERO
+.global ret_from_kernel_thread
+ret_from_kernel_thread:
+        movi    schedule_tail,r5
+        ori     r5, 1, r5
+        ptabs   r5, tr0
+        blink   tr0, LINK
+        ld.q    SP, FRAME_R(2), r2
+        ld.q    SP, FRAME_R(3), r3
+        ptabs   r3, tr0
+        blink   tr0, LINK
+        ld.q    SP, FRAME_S(FSPC), r2
+        addi    r2, 4, r2               /* Move PC, being pre-execution event */
+        st.q    SP, FRAME_S(FSPC), r2
+        pta     ret_from_syscall, tr0
+        blink   tr0, ZERO
 syscall_allowed:
        /* Use LINK to deflect the exit point, default is syscall_ret */
        pta     syscall_ret, tr0
diff --git a/arch/sh/kernel/entry-common.S b/arch/sh/kernel/entry-common.S
index b96489d8b27d..9b6e4beeb296 100644
--- a/arch/sh/kernel/entry-common.S
+++ b/arch/sh/kernel/entry-common.S
@@ -297,6 +297,19 @@ ret_from_fork:
         mov    r0, r4
        bra     syscall_exit
         nop
+        .align  2
+        .globl  ret_from_kernel_thread
+ret_from_kernel_thread:
+        mov.l   1f, r8
+        jsr     @r8
+         mov    r0, r4
+        mov.l   @(OFF_R5,r15), r5   ! fn
+        jsr     @r5
+         mov.l  @(OFF_R4,r15), r4   ! arg
+        bra     syscall_exit
+         nop
        .align  2
 1:      .long   schedule_tail
diff --git a/arch/sh/kernel/process_32.c b/arch/sh/kernel/process_32.c
index ba7345f37bc9..73eb66fc6253 100644
--- a/arch/sh/kernel/process_32.c
+++ b/arch/sh/kernel/process_32.c
@@ -68,38 +68,6 @@ void show_regs(struct pt_regs * regs)
        show_code(regs);
 }
-/*
- * Create a kernel thread
- */
-__noreturn void kernel_thread_helper(void *arg, int (*fn)(void *))
-{
-        do_exit(fn(arg));
-}
-/* Don't use this in BL=1(cli).  Or else, CPU resets! */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        int pid;
-        memset(&regs, 0, sizeof(regs));
-        regs.regs[4] = (unsigned long)arg;
-        regs.regs[5] = (unsigned long)fn;
-        regs.pc = (unsigned long)kernel_thread_helper;
-        regs.sr = SR_MD;
-#if defined(CONFIG_SH_FPU)
-        regs.sr |= SR_FD;
-#endif
-        /* Ok, create the new process.. */
-        pid = do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0,
-                      &regs, 0, NULL, NULL);
-        return pid;
-}
-EXPORT_SYMBOL(kernel_thread);
 void start_thread(struct pt_regs *regs, unsigned long new_pc,
                  unsigned long new_sp)
 {
@@ -157,10 +125,10 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 EXPORT_SYMBOL(dump_fpu);
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct thread_info *ti = task_thread_info(p);
        struct pt_regs *childregs;
@@ -177,29 +145,35 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
        }
 #endif
-        childregs = task_pt_regs(p);
+        memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
-        *childregs = *regs;
-        if (user_mode(regs)) {
+        childregs = task_pt_regs(p);
-                childregs->regs[15] = usp;
+        p->thread.sp = (unsigned long) childregs;
-                ti->addr_limit = USER_DS;
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        } else {
+                memset(childregs, 0, sizeof(struct pt_regs));
-                childregs->regs[15] = (unsigned long)childregs;
+                p->thread.pc = (unsigned long) ret_from_kernel_thread;
+                childregs->regs[4] = arg;
+                childregs->regs[5] = usp;
+                childregs->sr = SR_MD;
+#if defined(CONFIG_SH_FPU)
+                childregs->sr |= SR_FD;
+#endif
                ti->addr_limit = KERNEL_DS;
                ti->status &= ~TS_USEDFPU;
                p->fpu_counter = 0;
+                return 0;
        }
+        *childregs = *current_pt_regs();
+        if (usp)
+                childregs->regs[15] = usp;
+        ti->addr_limit = USER_DS;
        if (clone_flags & CLONE_SETTLS)
                childregs->gbr = childregs->regs[0];
        childregs->regs[0] = 0; /* Set return value for child */
-        p->thread.sp = (unsigned long) childregs;
        p->thread.pc = (unsigned long) ret_from_fork;
-        memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
        return 0;
 }
@@ -243,74 +217,6 @@ __switch_to(struct task_struct *prev, struct task_struct *next)
        return prev;
 }
-asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
-                        unsigned long r6, unsigned long r7,
-                        struct pt_regs __regs)
-{
-#ifdef CONFIG_MMU
-        struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
-        return do_fork(SIGCHLD, regs->regs[15], regs, 0, NULL, NULL);
-#else
-        /* fork almost works, enough to trick you into looking elsewhere :-( */
-        return -EINVAL;
-#endif
-}
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long parent_tidptr,
-                         unsigned long child_tidptr,
-                         struct pt_regs __regs)
-{
-        struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
-        if (!newsp)
-                newsp = regs->regs[15];
-        return do_fork(clone_flags, newsp, regs, 0,
-                        (int __user *)parent_tidptr,
-                        (int __user *)child_tidptr);
-}
-/*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
-asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs __regs)
-{
-        struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->regs[15], regs,
-                       0, NULL, NULL);
-}
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char __user *ufilename,
-                          const char __user *const __user *uargv,
-                          const char __user *const __user *uenvp,
-                          unsigned long r7, struct pt_regs __regs)
-{
-        struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
-        int error;
-        struct filename *filename;
-        filename = getname(ufilename);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, uargv, uenvp, regs);
-        putname(filename);
-out:
-        return error;
-}
 unsigned long get_wchan(struct task_struct *p)
 {
        unsigned long pc;
diff --git a/arch/sh/kernel/process_64.c b/arch/sh/kernel/process_64.c
index 98a709f0c3c4..e611c85144b1 100644
--- a/arch/sh/kernel/process_64.c
+++ b/arch/sh/kernel/process_64.c
@@ -285,39 +285,6 @@ void show_regs(struct pt_regs *regs)
 }
 /*
- * Create a kernel thread
- */
-__noreturn void kernel_thread_helper(void *arg, int (*fn)(void *))
-{
-        do_exit(fn(arg));
-}
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be freed until both the parent and the child have exited.
- */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.regs[2] = (unsigned long)arg;
-        regs.regs[3] = (unsigned long)fn;
-        regs.pc = (unsigned long)kernel_thread_helper;
-        regs.sr = (1 << 30);
-        /* Ok, create the new process.. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0,
-                      &regs, 0, NULL, NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
-/*
 * Free current thread data structures etc..
 */
 void exit_thread(void)
@@ -401,26 +368,37 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 EXPORT_SYMBOL(dump_fpu);
 asmlinkage void ret_from_fork(void);
+asmlinkage void ret_from_kernel_thread(void);
 int copy_thread(unsigned long clone_flags, unsigned long usp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs *childregs;
+        struct pt_regs *childregs, *regs = current_pt_regs();
 #ifdef CONFIG_SH_FPU
-        if(last_task_used_math == current) {
+        /* can't happen for a kernel thread */
+        if (last_task_used_math == current) {
                enable_fpu();
                save_fpu(current);
                disable_fpu();
                last_task_used_math = NULL;
-                regs->sr |= SR_FD;
+                current_pt_regs()->sr |= SR_FD;
        }
 #endif
        /* Copy from sh version */
        childregs = (struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1;
+        p->thread.sp = (unsigned long) childregs;
-        *childregs = *regs;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                memset(childregs, 0, sizeof(struct pt_regs));
+                childregs->regs[2] = (unsigned long)arg;
+                childregs->regs[3] = (unsigned long)fn;
+                childregs->sr = (1 << 30); /* not user_mode */
+                childregs->sr |= SR_FD; /* Invalidate FPU flag */
+                p->thread.pc = (unsigned long) ret_from_kernel_thread;
+                return 0;
+        }
+        *childregs = *current_pt_regs();
        /*
         * Sign extend the edited stack.
@@ -428,85 +406,18 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         * 32-bit wide and context switch must take care
         * of NEFF sign extension.
         */
-        if (user_mode(regs)) {
+        if (usp)
                childregs->regs[15] = neff_sign_extend(usp);
-                p->thread.uregs = childregs;
+        p->thread.uregs = childregs;
-        } else {
-                childregs->regs[15] =
-                        neff_sign_extend((unsigned long)task_stack_page(p) +
-                                         THREAD_SIZE);
-        }
        childregs->regs[9] = 0; /* Set return value for child */
        childregs->sr |= SR_FD; /* Invalidate FPU flag */
-        p->thread.sp = (unsigned long) childregs;
        p->thread.pc = (unsigned long) ret_from_fork;
        return 0;
 }
-asmlinkage int sys_fork(unsigned long r2, unsigned long r3,
-                        unsigned long r4, unsigned long r5,
-                        unsigned long r6, unsigned long r7,
-                        struct pt_regs *pregs)
-{
-        return do_fork(SIGCHLD, pregs->regs[15], pregs, 0, 0, 0);
-}
-asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs *pregs)
-{
-        if (!newsp)
-                newsp = pregs->regs[15];
-        return do_fork(clone_flags, newsp, pregs, 0, 0, 0);
-}
-/*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
-asmlinkage int sys_vfork(unsigned long r2, unsigned long r3,
-                         unsigned long r4, unsigned long r5,
-                         unsigned long r6, unsigned long r7,
-                         struct pt_regs *pregs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, pregs->regs[15], pregs, 0, 0, 0);
-}
-/*
- * sys_execve() executes a new program.
- */
-asmlinkage int sys_execve(const char *ufilename, char **uargv,
-                          char **uenvp, unsigned long r5,
-                          unsigned long r6, unsigned long r7,
-                          struct pt_regs *pregs)
-{
-        int error;
-        struct filename *filename;
-        filename = getname((char __user *)ufilename);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name,
-                          (const char __user *const __user *)uargv,
-                          (const char __user *const __user *)uenvp,
-                          pregs);
-        putname(filename);
-out:
-        return error;
-}
 #ifdef CONFIG_FRAME_POINTER
 static int in_sh64_switch_to(unsigned long pc)
 {
diff --git a/arch/sh/kernel/sys_sh32.c b/arch/sh/kernel/sys_sh32.c
index f56b6fe5c5d0..497bab3a0401 100644
--- a/arch/sh/kernel/sys_sh32.c
+++ b/arch/sh/kernel/sys_sh32.c
@@ -60,27 +60,3 @@ asmlinkage int sys_fadvise64_64_wrapper(int fd, u32 offset0, u32 offset1,
                                (u64)len0 << 32 | len1, advice);
 #endif
 }
-#if defined(CONFIG_CPU_SH2) || defined(CONFIG_CPU_SH2A)
-#define SYSCALL_ARG3    "trapa #0x23"
-#else
-#define SYSCALL_ARG3    "trapa #0x13"
-#endif
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register long __sc0 __asm__ ("r3") = __NR_execve;
-        register long __sc4 __asm__ ("r4") = (long) filename;
-        register long __sc5 __asm__ ("r5") = (long) argv;
-        register long __sc6 __asm__ ("r6") = (long) envp;
-        __asm__ __volatile__ (SYSCALL_ARG3 : "=z" (__sc0)
-                        : "0" (__sc0), "r" (__sc4), "r" (__sc5), "r" (__sc6)
-                        : "memory");
-        return __sc0;
-}
diff --git a/arch/sh/kernel/sys_sh64.c b/arch/sh/kernel/sys_sh64.c
deleted file mode 100644
index c5a38c4bf410..000000000000
--- a/arch/sh/kernel/sys_sh64.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * arch/sh/kernel/sys_sh64.c
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- *
- * This file contains various random system calls that
- * have a non-standard calling sequence on the Linux/SH5
- * platform.
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- */
-#include <linux/errno.h>
-#include <linux/rwsem.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
-#include <linux/fs.h>
-#include <linux/smp.h>
-#include <linux/sem.h>
-#include <linux/msg.h>
-#include <linux/shm.h>
-#include <linux/stat.h>
-#include <linux/mman.h>
-#include <linux/file.h>
-#include <linux/syscalls.h>
-#include <linux/ipc.h>
-#include <asm/uaccess.h>
-#include <asm/ptrace.h>
-#include <asm/unistd.h>
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        register unsigned long __sc0 __asm__ ("r9") = ((0x13 << 16) | __NR_execve);
-        register unsigned long __sc2 __asm__ ("r2") = (unsigned long) filename;
-        register unsigned long __sc3 __asm__ ("r3") = (unsigned long) argv;
-        register unsigned long __sc4 __asm__ ("r4") = (unsigned long) envp;
-        __asm__ __volatile__ ("trapa    %1 !\t\t\t execve(%2,%3,%4)"
-        : "=r" (__sc0)
-        : "r" (__sc0), "r" (__sc2), "r" (__sc3), "r" (__sc4) );
-        __asm__ __volatile__ ("!dummy   %0 %1 %2 %3"
-        : : "r" (__sc0), "r" (__sc2), "r" (__sc3), "r" (__sc4) : "memory");
-        return __sc0;
-}
diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
index 9f2edb5c5551..0c7d365fa402 100644
--- a/arch/sparc/Kconfig
+++ b/arch/sparc/Kconfig
@@ -41,6 +41,8 @@ config SPARC
        select GENERIC_STRNCPY_FROM_USER
        select GENERIC_STRNLEN_USER
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 config SPARC32
        def_bool !64BIT
diff --git a/arch/sparc/include/asm/processor_32.h b/arch/sparc/include/asm/processor_32.h
index f74ac9ee33a8..c1e01914fd98 100644
--- a/arch/sparc/include/asm/processor_32.h
+++ b/arch/sparc/include/asm/processor_32.h
@@ -106,7 +106,6 @@ static inline void start_thread(struct pt_regs * regs, unsigned long pc,
 /* Free all resources held by a thread. */
 #define release_thread(tsk)             do { } while(0)
-extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 extern unsigned long get_wchan(struct task_struct *);
diff --git a/arch/sparc/include/asm/processor_64.h b/arch/sparc/include/asm/processor_64.h
index 721e25f0e2ea..cce72ce4c334 100644
--- a/arch/sparc/include/asm/processor_64.h
+++ b/arch/sparc/include/asm/processor_64.h
@@ -94,6 +94,7 @@ struct thread_struct {
 #ifndef __ASSEMBLY__
 #include <linux/types.h>
+#include <asm/fpumacro.h>
 /* Return saved PC of a blocked thread. */
 struct task_struct;
@@ -143,6 +144,10 @@ do { \
        : \
        : "r" (regs), "r" (sp - sizeof(struct reg_window) - STACK_BIAS), \
          "i" ((const unsigned long)(&((struct pt_regs *)0)->u_regs[0]))); \
+        fprs_write(0);  \
+        current_thread_info()->xfsr[0] = 0;     \
+        current_thread_info()->fpsaved[0] = 0;  \
+        regs->tstate &= ~TSTATE_PEF;    \
 } while (0)
 #define start_thread32(regs, pc, sp) \
@@ -183,13 +188,15 @@ do { \
        : \
        : "r" (regs), "r" (sp - sizeof(struct reg_window32)), \
          "i" ((const unsigned long)(&((struct pt_regs *)0)->u_regs[0]))); \
+        fprs_write(0);  \
+        current_thread_info()->xfsr[0] = 0;     \
+        current_thread_info()->fpsaved[0] = 0;  \
+        regs->tstate &= ~TSTATE_PEF;    \
 } while (0)
 /* Free all resources held by a thread. */
 #define release_thread(tsk)             do { } while (0)
-extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 extern unsigned long get_wchan(struct task_struct *task);
 #define task_pt_regs(tsk) (task_thread_info(tsk)->kregs)
diff --git a/arch/sparc/include/asm/ptrace.h b/arch/sparc/include/asm/ptrace.h
index da43bdc62294..bdfafd7af46f 100644
--- a/arch/sparc/include/asm/ptrace.h
+++ b/arch/sparc/include/asm/ptrace.h
@@ -32,6 +32,9 @@ static inline bool pt_regs_clear_syscall(struct pt_regs *regs)
 #define arch_ptrace_stop(exit_code, info) \
        synchronize_user_stack()
+#define current_pt_regs() \
+        ((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE) - 1)
 struct global_reg_snapshot {
        unsigned long           tstate;
        unsigned long           tpc;
@@ -55,9 +58,7 @@ union global_cpu_snapshot {
 extern union global_cpu_snapshot global_cpu_snapshot[NR_CPUS];
-#define force_successful_syscall_return()           \
+#define force_successful_syscall_return() set_thread_noerror(1)
-do {    current_thread_info()->syscall_noerror = 1; \
-} while (0)
 #define user_mode(regs) (!((regs)->tstate & TSTATE_PRIV))
 #define instruction_pointer(regs) ((regs)->tpc)
 #define instruction_pointer_set(regs, val) ((regs)->tpc = (val))
@@ -100,6 +101,9 @@ static inline bool pt_regs_clear_syscall(struct pt_regs *regs)
 #define arch_ptrace_stop(exit_code, info) \
        synchronize_user_stack()
+#define current_pt_regs() \
+        ((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE) - 1)
 #define user_mode(regs) (!((regs)->psr & PSR_PS))
 #define instruction_pointer(regs) ((regs)->pc)
 #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP])
diff --git a/arch/sparc/include/asm/signal.h b/arch/sparc/include/asm/signal.h
index d243c2ae02d2..77b85850d543 100644
--- a/arch/sparc/include/asm/signal.h
+++ b/arch/sparc/include/asm/signal.h
@@ -26,7 +26,5 @@ struct k_sigaction {
        void                    __user *ka_restorer;
 };
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* !(__ASSEMBLY__) */
 #endif /* !(__SPARC_SIGNAL_H) */
diff --git a/arch/sparc/include/asm/switch_to_64.h b/arch/sparc/include/asm/switch_to_64.h
index 7923c4a2be38..cad36f56fa03 100644
--- a/arch/sparc/include/asm/switch_to_64.h
+++ b/arch/sparc/include/asm/switch_to_64.h
@@ -23,7 +23,7 @@ do {	flush_tlb_pending();						\
        /* If you are tempted to conditionalize the following */        \
        /* so that ASI is only written if it changes, think again. */   \
        __asm__ __volatile__("wr %%g0, %0, %%asi"                       \
-        : : "r" (__thread_flag_byte_ptr(task_thread_info(next))[TI_FLAG_BYTE_CURRENT_DS]));\
+        : : "r" (task_thread_info(next)->current_ds));\
        trap_block[current_thread_info()->cpu].thread =                 \
                task_thread_info(next);                                 \
        __asm__ __volatile__(                                           \
diff --git a/arch/sparc/include/asm/syscalls.h b/arch/sparc/include/asm/syscalls.h
index 45a43f637a14..bf8972adea17 100644
--- a/arch/sparc/include/asm/syscalls.h
+++ b/arch/sparc/include/asm/syscalls.h
@@ -8,6 +8,4 @@ extern asmlinkage long sparc_do_fork(unsigned long clone_flags,
                                     struct pt_regs *regs,
                                     unsigned long stack_size);
-extern asmlinkage int sparc_execve(struct pt_regs *regs);
 #endif /* _SPARC64_SYSCALLS_H */
diff --git a/arch/sparc/include/asm/thread_info_64.h b/arch/sparc/include/asm/thread_info_64.h
index a3fe4dcc0aa6..269bd92313df 100644
--- a/arch/sparc/include/asm/thread_info_64.h
+++ b/arch/sparc/include/asm/thread_info_64.h
@@ -14,12 +14,12 @@
 #define TI_FLAG_FAULT_CODE_SHIFT        56
 #define TI_FLAG_BYTE_WSTATE             1
 #define TI_FLAG_WSTATE_SHIFT            48
-#define TI_FLAG_BYTE_CWP                2
+#define TI_FLAG_BYTE_NOERROR            2
-#define TI_FLAG_CWP_SHIFT               40
+#define TI_FLAG_BYTE_NOERROR_SHIFT      40
-#define TI_FLAG_BYTE_CURRENT_DS         3
+#define TI_FLAG_BYTE_FPDEPTH            3
-#define TI_FLAG_CURRENT_DS_SHIFT        32
+#define TI_FLAG_FPDEPTH_SHIFT           32
-#define TI_FLAG_BYTE_FPDEPTH            4
+#define TI_FLAG_BYTE_CWP                4
-#define TI_FLAG_FPDEPTH_SHIFT           24
+#define TI_FLAG_CWP_SHIFT               24
 #define TI_FLAG_BYTE_WSAVED             5
 #define TI_FLAG_WSAVED_SHIFT            16
@@ -47,7 +47,7 @@ struct thread_info {
        struct exec_domain      *exec_domain;
        int                     preempt_count;  /* 0 => preemptable, <0 => BUG */
        __u8                    new_child;
-        __u8                    syscall_noerror;
+        __u8                    current_ds;
        __u16                   cpu;
        unsigned long           *utraps;
@@ -74,9 +74,9 @@ struct thread_info {
 #define TI_FAULT_CODE   (TI_FLAGS + TI_FLAG_BYTE_FAULT_CODE)
 #define TI_WSTATE       (TI_FLAGS + TI_FLAG_BYTE_WSTATE)
 #define TI_CWP          (TI_FLAGS + TI_FLAG_BYTE_CWP)
-#define TI_CURRENT_DS   (TI_FLAGS + TI_FLAG_BYTE_CURRENT_DS)
 #define TI_FPDEPTH      (TI_FLAGS + TI_FLAG_BYTE_FPDEPTH)
 #define TI_WSAVED       (TI_FLAGS + TI_FLAG_BYTE_WSAVED)
+#define TI_SYS_NOERROR  (TI_FLAGS + TI_FLAG_BYTE_NOERROR)
 #define TI_FPSAVED      0x00000010
 #define TI_KSP          0x00000018
 #define TI_FAULT_ADDR   0x00000020
@@ -84,7 +84,7 @@ struct thread_info {
 #define TI_EXEC_DOMAIN  0x00000030
 #define TI_PRE_COUNT    0x00000038
 #define TI_NEW_CHILD    0x0000003c
-#define TI_SYS_NOERROR  0x0000003d
+#define TI_CURRENT_DS   0x0000003d
 #define TI_CPU          0x0000003e
 #define TI_UTRAPS       0x00000040
 #define TI_REG_WINDOW   0x00000048
@@ -121,7 +121,7 @@ struct thread_info {
 #define INIT_THREAD_INFO(tsk)                           \
 {                                                       \
        .task           =       &tsk,                   \
-        .flags          = ((unsigned long)ASI_P) << TI_FLAG_CURRENT_DS_SHIFT,   \
+        .current_ds     =       ASI_P,                  \
        .exec_domain    =       &default_exec_domain,   \
        .preempt_count  =       INIT_PREEMPT_COUNT,     \
        .restart_block  = {                             \
@@ -153,13 +153,12 @@ register struct thread_info *current_thread_info_reg asm("g6");
 #define set_thread_wstate(val)          (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE] = (val))
 #define get_thread_cwp()                (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP])
 #define set_thread_cwp(val)             (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP] = (val))
-#define get_thread_current_ds()         (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CURRENT_DS])
+#define get_thread_noerror()            (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR])
-#define set_thread_current_ds(val)      (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CURRENT_DS] = (val))
+#define set_thread_noerror(val)         (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR] = (val))
 #define get_thread_fpdepth()            (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH])
 #define set_thread_fpdepth(val)         (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH] = (val))
 #define get_thread_wsaved()             (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED])
 #define set_thread_wsaved(val)          (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED] = (val))
 #endif /* !(__ASSEMBLY__) */
 /*
diff --git a/arch/sparc/include/asm/uaccess_64.h b/arch/sparc/include/asm/uaccess_64.h
index 73083e1d38d9..e562d3caee57 100644
--- a/arch/sparc/include/asm/uaccess_64.h
+++ b/arch/sparc/include/asm/uaccess_64.h
@@ -38,14 +38,14 @@
 #define VERIFY_READ     0
 #define VERIFY_WRITE    1
-#define get_fs() ((mm_segment_t) { get_thread_current_ds() })
+#define get_fs() ((mm_segment_t){(current_thread_info()->current_ds)})
 #define get_ds() (KERNEL_DS)
 #define segment_eq(a,b)  ((a).seg == (b).seg)
 #define set_fs(val)                                                             \
 do {                                                                            \
-        set_thread_current_ds((val).seg);                                       \
+        current_thread_info()->current_ds =(val).seg;                           \
        __asm__ __volatile__ ("wr %%g0, %0, %%asi" : : "r" ((val).seg));        \
 } while(0)
diff --git a/arch/sparc/include/asm/unistd.h b/arch/sparc/include/asm/unistd.h
index 0ecea6ed943e..c3e5d8b64171 100644
--- a/arch/sparc/include/asm/unistd.h
+++ b/arch/sparc/include/asm/unistd.h
@@ -46,6 +46,7 @@
 #define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 #define __ARCH_WANT_COMPAT_SYS_SENDFILE
 #endif
+#define __ARCH_WANT_SYS_EXECVE
 /*
 * "Conditional" syscalls
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index dcaa1cf0de40..21fd1a8f47d2 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -806,23 +806,10 @@ sys_nis_syscall:
        call    c_sys_nis_syscall
         mov    %l5, %o7
-        .align  4
-        .globl  sys_execve
-sys_execve:
-        mov     %o7, %l5
-        add     %sp, STACKFRAME_SZ, %o0         ! pt_regs *regs arg
-        call    sparc_execve
-         mov    %l5, %o7
-        .globl  sunos_execv
 sunos_execv:
-        st      %g0, [%sp + STACKFRAME_SZ + PT_I2]
+        .globl  sunos_execv
+        b       sys_execve
-        call    sparc_execve
+         clr    %i2
-         add    %sp, STACKFRAME_SZ, %o0
-        b       ret_sys_call
-         ld     [%sp + STACKFRAME_SZ + PT_I0], %o0
        .align  4
        .globl  sys_sparc_pipe
@@ -959,17 +946,9 @@ flush_patch_four:
        .align  4
 linux_sparc_ni_syscall:
        sethi   %hi(sys_ni_syscall), %l7
-        b       syscall_is_too_hard
+        b       do_syscall
         or     %l7, %lo(sys_ni_syscall), %l7
-linux_fast_syscall:
-        andn    %l7, 3, %l7
-        mov     %i0, %o0
-        mov     %i1, %o1
-        mov     %i2, %o2
-        jmpl    %l7 + %g0, %g0
-         mov    %i3, %o3
 linux_syscall_trace:
        add     %sp, STACKFRAME_SZ, %o0
        call    syscall_trace
@@ -991,6 +970,23 @@ ret_from_fork:
        b       ret_sys_call
         ld     [%sp + STACKFRAME_SZ + PT_I0], %o0
+        .globl  ret_from_kernel_thread
+ret_from_kernel_thread:
+        call    schedule_tail
+         ld     [%g3 + TI_TASK], %o0
+        ld      [%sp + STACKFRAME_SZ + PT_G1], %l0
+        call    %l0
+         ld     [%sp + STACKFRAME_SZ + PT_G2], %o0
+        rd      %psr, %l1
+        ld      [%sp + STACKFRAME_SZ + PT_PSR], %l0
+        andn    %l0, PSR_CWP, %l0
+        nop
+        and     %l1, PSR_CWP, %l1
+        or      %l0, %l1, %l0
+        st      %l0, [%sp + STACKFRAME_SZ + PT_PSR]
+        b       ret_sys_call
+         mov    0, %o0
        /* Linux native system calls enter here... */
        .align  4
        .globl  linux_sparc_syscall
@@ -1002,11 +998,8 @@ linux_sparc_syscall:
        bgeu    linux_sparc_ni_syscall
         sll    %g1, 2, %l4
        ld      [%l7 + %l4], %l7
-        andcc   %l7, 1, %g0
-        bne     linux_fast_syscall
-         /* Just do first insn from SAVE_ALL in the delay slot */
-syscall_is_too_hard:
+do_syscall:
        SAVE_ALL_HEAD
         rd     %wim, %l3
diff --git a/arch/sparc/kernel/etrap_64.S b/arch/sparc/kernel/etrap_64.S
index 786b185e6e3f..1276ca2567ba 100644
--- a/arch/sparc/kernel/etrap_64.S
+++ b/arch/sparc/kernel/etrap_64.S
@@ -92,8 +92,10 @@ etrap_save:	save	%g2, -STACK_BIAS, %sp
                rdpr    %wstate, %g2
                wrpr    %g0, 0, %canrestore
                sll     %g2, 3, %g2
+                /* Set TI_SYS_FPDEPTH to 1 and clear TI_SYS_NOERROR.  */
                mov     1, %l5
-                stb     %l5, [%l6 + TI_FPDEPTH]
+                sth     %l5, [%l6 + TI_SYS_NOERROR]
                wrpr    %g3, 0, %otherwin
                wrpr    %g2, 0, %wstate
@@ -152,7 +154,9 @@ etrap_save:	save	%g2, -STACK_BIAS, %sp
                add     %l6, TI_FPSAVED + 1, %l4
                srl     %l5, 1, %l3
                add     %l5, 2, %l5
-                stb     %l5, [%l6 + TI_FPDEPTH]
+                /* Set TI_SYS_FPDEPTH to %l5 and clear TI_SYS_NOERROR.  */
+                sth     %l5, [%l6 + TI_SYS_NOERROR]
                ba,pt   %xcc, 2b
                 stb    %g0, [%l4 + %l3]
                nop
diff --git a/arch/sparc/kernel/process_32.c b/arch/sparc/kernel/process_32.c
index 487bffb36f5e..be8e862badaf 100644
--- a/arch/sparc/kernel/process_32.c
+++ b/arch/sparc/kernel/process_32.c
@@ -286,8 +286,7 @@ asmlinkage int sparc_do_fork(unsigned long clone_flags,
        parent_tid_ptr = regs->u_regs[UREG_I2];
        child_tid_ptr = regs->u_regs[UREG_I4];
-        ret = do_fork(clone_flags, stack_start,
+        ret = do_fork(clone_flags, stack_start, stack_size,
-                      regs, stack_size,
                      (int __user *) parent_tid_ptr,
                      (int __user *) child_tid_ptr);
@@ -316,13 +315,13 @@ asmlinkage int sparc_do_fork(unsigned long clone_flags,
 * XXX See comment above sys_vfork in sparc64. todo.
 */
 extern void ret_from_fork(void);
+extern void ret_from_kernel_thread(void);
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct thread_info *ti = task_thread_info(p);
-        struct pt_regs *childregs;
+        struct pt_regs *childregs, *regs = current_pt_regs();
        char *new_stack;
 #ifndef CONFIG_SMP
@@ -336,16 +335,13 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
        }
        /*
-         *  p->thread_info         new_stack   childregs
+         *  p->thread_info         new_stack   childregs stack bottom
-         *  !                      !           !             {if(PSR_PS) }
+         *  !                      !           !             !
-         *  V                      V (stk.fr.) V  (pt_regs)  { (stk.fr.) }
+         *  V                      V (stk.fr.) V  (pt_regs)  V
-         *  +----- - - - - - ------+===========+============={+==========}+
+         *  +----- - - - - - ------+===========+=============+
         */
        new_stack = task_stack_page(p) + THREAD_SIZE;
-        if (regs->psr & PSR_PS)
-                new_stack -= STACKFRAME_SZ;
        new_stack -= STACKFRAME_SZ + TRACEREG_SZ;
-        memcpy(new_stack, (char *)regs - STACKFRAME_SZ, STACKFRAME_SZ + TRACEREG_SZ);
        childregs = (struct pt_regs *) (new_stack + STACKFRAME_SZ);
        /*
@@ -356,55 +352,58 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
         * Thus, kpsr|=PSR_PIL.
         */
        ti->ksp = (unsigned long) new_stack;
+        p->thread.kregs = childregs;
+        if (unlikely(p->flags & PF_KTHREAD)) {
+                extern int nwindows;
+                unsigned long psr;
+                memset(new_stack, 0, STACKFRAME_SZ + TRACEREG_SZ);
+                p->thread.flags |= SPARC_FLAG_KTHREAD;
+                p->thread.current_ds = KERNEL_DS;
+                ti->kpc = (((unsigned long) ret_from_kernel_thread) - 0x8);
+                childregs->u_regs[UREG_G1] = sp; /* function */
+                childregs->u_regs[UREG_G2] = arg;
+                psr = childregs->psr = get_psr();
+                ti->kpsr = psr | PSR_PIL;
+                ti->kwim = 1 << (((psr & PSR_CWP) + 1) % nwindows);
+                return 0;
+        }
+        memcpy(new_stack, (char *)regs - STACKFRAME_SZ, STACKFRAME_SZ + TRACEREG_SZ);
+        childregs->u_regs[UREG_FP] = sp;
+        p->thread.flags &= ~SPARC_FLAG_KTHREAD;
+        p->thread.current_ds = USER_DS;
        ti->kpc = (((unsigned long) ret_from_fork) - 0x8);
        ti->kpsr = current->thread.fork_kpsr | PSR_PIL;
        ti->kwim = current->thread.fork_kwim;
-        if(regs->psr & PSR_PS) {
+        if (sp != regs->u_regs[UREG_FP]) {
-                extern struct pt_regs fake_swapper_regs;
+                struct sparc_stackf __user *childstack;
+                struct sparc_stackf __user *parentstack;
-                p->thread.kregs = &fake_swapper_regs;
+                /*
-                new_stack += STACKFRAME_SZ + TRACEREG_SZ;
+                 * This is a clone() call with supplied user stack.
-                childregs->u_regs[UREG_FP] = (unsigned long) new_stack;
+                 * Set some valid stack frames to give to the child.
-                p->thread.flags |= SPARC_FLAG_KTHREAD;
+                 */
-                p->thread.current_ds = KERNEL_DS;
+                childstack = (struct sparc_stackf __user *)
-                memcpy(new_stack, (void *)regs->u_regs[UREG_FP], STACKFRAME_SZ);
+                        (sp & ~0xfUL);
-                childregs->u_regs[UREG_G6] = (unsigned long) ti;
+                parentstack = (struct sparc_stackf __user *)
-        } else {
+                        regs->u_regs[UREG_FP];
-                p->thread.kregs = childregs;
-                childregs->u_regs[UREG_FP] = sp;
-                p->thread.flags &= ~SPARC_FLAG_KTHREAD;
-                p->thread.current_ds = USER_DS;
-                if (sp != regs->u_regs[UREG_FP]) {
-                        struct sparc_stackf __user *childstack;
-                        struct sparc_stackf __user *parentstack;
-                        /*
-                         * This is a clone() call with supplied user stack.
-                         * Set some valid stack frames to give to the child.
-                         */
-                        childstack = (struct sparc_stackf __user *)
-                                (sp & ~0xfUL);
-                        parentstack = (struct sparc_stackf __user *)
-                                regs->u_regs[UREG_FP];
 #if 0
-                        printk("clone: parent stack:\n");
+                printk("clone: parent stack:\n");
-                        show_stackframe(parentstack);
+                show_stackframe(parentstack);
 #endif
-                        childstack = clone_stackframe(childstack, parentstack);
+                childstack = clone_stackframe(childstack, parentstack);
-                        if (!childstack)
+                if (!childstack)
-                                return -EFAULT;
+                        return -EFAULT;
 #if 0
-                        printk("clone: child stack:\n");
+                printk("clone: child stack:\n");
-                        show_stackframe(childstack);
+                show_stackframe(childstack);
 #endif
-                        childregs->u_regs[UREG_FP] = (unsigned long)childstack;
+                childregs->u_regs[UREG_FP] = (unsigned long)childstack;
-                }
        }
 #ifdef CONFIG_SMP
@@ -475,69 +474,6 @@ int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
        return 1;
 }
-/*
- * sparc_execve() executes a new program after the asm stub has set
- * things up for us.  This should basically do what I want it to.
- */
-asmlinkage int sparc_execve(struct pt_regs *regs)
-{
-        int error, base = 0;
-        struct filename *filename;
-        /* Check for indirect call. */
-        if(regs->u_regs[UREG_G1] == 0)
-                base = 1;
-        filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
-        error = PTR_ERR(filename);
-        if(IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name,
-                          (const char __user *const  __user *)
-                          regs->u_regs[base + UREG_I1],
-                          (const char __user *const  __user *)
-                          regs->u_regs[base + UREG_I2],
-                          regs);
-        putname(filename);
-out:
-        return error;
-}
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be freed until both the parent and the child have exited.
- */
-pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        long retval;
-        __asm__ __volatile__("mov %4, %%g2\n\t"    /* Set aside fn ptr... */
-                             "mov %5, %%g3\n\t"    /* and arg. */
-                             "mov %1, %%g1\n\t"
-                             "mov %2, %%o0\n\t"    /* Clone flags. */
-                             "mov 0, %%o1\n\t"     /* usp arg == 0 */
-                             "t 0x10\n\t"          /* Linux/Sparc clone(). */
-                             "cmp %%o1, 0\n\t"
-                             "be 1f\n\t"           /* The parent, just return. */
-                             " nop\n\t"            /* Delay slot. */
-                             "jmpl %%g2, %%o7\n\t" /* Call the function. */
-                             " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */
-                             "mov %3, %%g1\n\t"
-                             "t 0x10\n\t"          /* Linux/Sparc exit(). */
-                             /* Notreached by child. */
-                             "1: mov %%o0, %0\n\t" :
-                             "=r" (retval) :
-                             "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
-                             "i" (__NR_exit),  "r" (fn), "r" (arg) :
-                             "g1", "g2", "g3", "o0", "o1", "memory", "cc");
-        return retval;
-}
-EXPORT_SYMBOL(kernel_thread);
 unsigned long get_wchan(struct task_struct *task)
 {
        unsigned long pc, fp, bias = 0;
diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c
index c6e0c2910043..cdb80b2adbe0 100644
--- a/arch/sparc/kernel/process_64.c
+++ b/arch/sparc/kernel/process_64.c
@@ -601,8 +601,7 @@ asmlinkage long sparc_do_fork(unsigned long clone_flags,
                child_tid_ptr = (int __user *) regs->u_regs[UREG_I4];
        }
-        ret = do_fork(clone_flags, stack_start,
+        ret = do_fork(clone_flags, stack_start, stack_size,
-                      regs, stack_size,
                      parent_tid_ptr, child_tid_ptr);
        /* If we get an error and potentially restart the system
@@ -622,64 +621,55 @@ asmlinkage long sparc_do_fork(unsigned long clone_flags,
 * Child  -->  %o0 == parents pid, %o1 == 1
 */
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-                unsigned long unused,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
        struct thread_info *t = task_thread_info(p);
+        struct pt_regs *regs = current_pt_regs();
        struct sparc_stackf *parent_sf;
        unsigned long child_stack_sz;
        char *child_trap_frame;
-        int kernel_thread;
-        kernel_thread = (regs->tstate & TSTATE_PRIV) ? 1 : 0;
-        parent_sf = ((struct sparc_stackf *) regs) - 1;
        /* Calculate offset to stack_frame & pt_regs */
-        child_stack_sz = ((STACKFRAME_SZ + TRACEREG_SZ) +
+        child_stack_sz = (STACKFRAME_SZ + TRACEREG_SZ);
-                          (kernel_thread ? STACKFRAME_SZ : 0));
        child_trap_frame = (task_stack_page(p) +
                            (THREAD_SIZE - child_stack_sz));
-        memcpy(child_trap_frame, parent_sf, child_stack_sz);
-        t->flags = (t->flags & ~((0xffUL << TI_FLAG_CWP_SHIFT) |
-                                 (0xffUL << TI_FLAG_CURRENT_DS_SHIFT))) |
-                (((regs->tstate + 1) & TSTATE_CWP) << TI_FLAG_CWP_SHIFT);
        t->new_child = 1;
        t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
        t->kregs = (struct pt_regs *) (child_trap_frame +
                                       sizeof(struct sparc_stackf));
        t->fpsaved[0] = 0;
-        if (kernel_thread) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
-                struct sparc_stackf *child_sf = (struct sparc_stackf *)
+                memset(child_trap_frame, 0, child_stack_sz);
-                        (child_trap_frame + (STACKFRAME_SZ + TRACEREG_SZ));
+                __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP] = 
+                        (current_pt_regs()->tstate + 1) & TSTATE_CWP;
-                /* Zero terminate the stack backtrace.  */
+                t->current_ds = ASI_P;
-                child_sf->fp = NULL;
+                t->kregs->u_regs[UREG_G1] = sp; /* function */
-                t->kregs->u_regs[UREG_FP] =
+                t->kregs->u_regs[UREG_G2] = arg;
-                  ((unsigned long) child_sf) - STACK_BIAS;
+                return 0;
+        }
-                t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT);
+        parent_sf = ((struct sparc_stackf *) regs) - 1;
-                t->kregs->u_regs[UREG_G6] = (unsigned long) t;
+        memcpy(child_trap_frame, parent_sf, child_stack_sz);
-                t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
+        if (t->flags & _TIF_32BIT) {
-        } else {
+                sp &= 0x00000000ffffffffUL;
-                if (t->flags & _TIF_32BIT) {
+                regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
-                        sp &= 0x00000000ffffffffUL;
-                        regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
-                }
-                t->kregs->u_regs[UREG_FP] = sp;
-                t->flags |= ((long)ASI_AIUS << TI_FLAG_CURRENT_DS_SHIFT);
-                if (sp != regs->u_regs[UREG_FP]) {
-                        unsigned long csp;
-                        csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
-                        if (!csp)
-                                return -EFAULT;
-                        t->kregs->u_regs[UREG_FP] = csp;
-                }
-                if (t->utraps)
-                        t->utraps[0]++;
        }
+        t->kregs->u_regs[UREG_FP] = sp;
+        __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP] = 
+                (regs->tstate + 1) & TSTATE_CWP;
+        t->current_ds = ASI_AIUS;
+        if (sp != regs->u_regs[UREG_FP]) {
+                unsigned long csp;
+                csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
+                if (!csp)
+                        return -EFAULT;
+                t->kregs->u_regs[UREG_FP] = csp;
+        }
+        if (t->utraps)
+                t->utraps[0]++;
        /* Set the return value for the child. */
        t->kregs->u_regs[UREG_I0] = current->pid;
@@ -694,45 +684,6 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
        return 0;
 }
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be freed until both the parent and the child have exited.
- */
-pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        long retval;
-        /* If the parent runs before fn(arg) is called by the child,
-         * the input registers of this function can be clobbered.
-         * So we stash 'fn' and 'arg' into global registers which
-         * will not be modified by the parent.
-         */
-        __asm__ __volatile__("mov %4, %%g2\n\t"    /* Save FN into global */
-                             "mov %5, %%g3\n\t"    /* Save ARG into global */
-                             "mov %1, %%g1\n\t"    /* Clone syscall nr. */
-                             "mov %2, %%o0\n\t"    /* Clone flags. */
-                             "mov 0, %%o1\n\t"     /* usp arg == 0 */
-                             "t 0x6d\n\t"          /* Linux/Sparc clone(). */
-                             "brz,a,pn %%o1, 1f\n\t" /* Parent, just return. */
-                             " mov %%o0, %0\n\t"
-                             "jmpl %%g2, %%o7\n\t"   /* Call the function. */
-                             " mov %%g3, %%o0\n\t"   /* Set arg in delay. */
-                             "mov %3, %%g1\n\t"
-                             "t 0x6d\n\t"          /* Linux/Sparc exit(). */
-                             /* Notreached by child. */
-                             "1:" :
-                             "=r" (retval) :
-                             "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
-                             "i" (__NR_exit),  "r" (fn), "r" (arg) :
-                             "g1", "g2", "g3", "o0", "o1", "memory", "cc");
-        return retval;
-}
-EXPORT_SYMBOL(kernel_thread);
 typedef struct {
        union {
                unsigned int    pr_regs[32];
@@ -799,41 +750,6 @@ int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
 }
 EXPORT_SYMBOL(dump_fpu);
-/*
- * sparc_execve() executes a new program after the asm stub has set
- * things up for us.  This should basically do what I want it to.
- */
-asmlinkage int sparc_execve(struct pt_regs *regs)
-{
-        int error, base = 0;
-        struct filename *filename;
-        /* User register window flush is done by entry.S */
-        /* Check for indirect call. */
-        if (regs->u_regs[UREG_G1] == 0)
-                base = 1;
-        filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name,
-                          (const char __user *const __user *)
-                          regs->u_regs[base + UREG_I1],
-                          (const char __user *const __user *)
-                          regs->u_regs[base + UREG_I2], regs);
-        putname(filename);
-        if (!error) {
-                fprs_write(0);
-                current_thread_info()->xfsr[0] = 0;
-                current_thread_info()->fpsaved[0] = 0;
-                regs->tstate &= ~TSTATE_PEF;
-        }
-out:
-        return error;
-}
 unsigned long get_wchan(struct task_struct *task)
 {
        unsigned long pc, fp, bias = 0;
diff --git a/arch/sparc/kernel/sys_sparc32.c b/arch/sparc/kernel/sys_sparc32.c
index c3239811a1b5..03c7e929ec34 100644
--- a/arch/sparc/kernel/sys_sparc32.c
+++ b/arch/sparc/kernel/sys_sparc32.c
@@ -396,42 +396,6 @@ asmlinkage long compat_sys_rt_sigaction(int sig,
        return ret;
 }
-/*
- * sparc32_execve() executes a new program after the asm stub has set
- * things up for us.  This should basically do what I want it to.
- */
-asmlinkage long sparc32_execve(struct pt_regs *regs)
-{
-        int error, base = 0;
-        struct filename *filename;
-        /* User register window flush is done by entry.S */
-        /* Check for indirect call. */
-        if ((u32)regs->u_regs[UREG_G1] == 0)
-                base = 1;
-        filename = getname(compat_ptr(regs->u_regs[base + UREG_I0]));
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = compat_do_execve(filename->name,
-                                 compat_ptr(regs->u_regs[base + UREG_I1]),
-                                 compat_ptr(regs->u_regs[base + UREG_I2]), regs);
-        putname(filename);
-        if (!error) {
-                fprs_write(0);
-                current_thread_info()->xfsr[0] = 0;
-                current_thread_info()->fpsaved[0] = 0;
-                regs->tstate &= ~TSTATE_PEF;
-        }
-out:
-        return error;
-}
 #ifdef CONFIG_MODULES
 asmlinkage long sys32_init_module(void __user *umod, u32 len,
diff --git a/arch/sparc/kernel/sys_sparc_32.c b/arch/sparc/kernel/sys_sparc_32.c
index 57277c830151..2da0bdcae52f 100644
--- a/arch/sparc/kernel/sys_sparc_32.c
+++ b/arch/sparc/kernel/sys_sparc_32.c
@@ -249,27 +249,3 @@ out:
        up_read(&uts_sem);
        return err;
 }
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        long __res;
-        register long __g1 __asm__ ("g1") = __NR_execve;
-        register long __o0 __asm__ ("o0") = (long)(filename);
-        register long __o1 __asm__ ("o1") = (long)(argv);
-        register long __o2 __asm__ ("o2") = (long)(envp);
-        asm volatile ("t 0x10\n\t"
-                      "bcc 1f\n\t"
-                      "mov %%o0, %0\n\t"
-                      "sub %%g0, %%o0, %0\n\t"
-                      "1:\n\t"
-                      : "=r" (__res), "=&r" (__o0)
-                      : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__g1)
-                      : "cc");
-        return __res;
-}
diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index 97309c0ec533..708bc29d36a8 100644
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -646,28 +646,6 @@ SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
        return ret;
 }
-/*
- * Do a system call from kernel instead of calling sys_execve so we
- * end up with proper pt_regs.
- */
-int kernel_execve(const char *filename,
-                  const char *const argv[],
-                  const char *const envp[])
-{
-        long __res;
-        register long __g1 __asm__ ("g1") = __NR_execve;
-        register long __o0 __asm__ ("o0") = (long)(filename);
-        register long __o1 __asm__ ("o1") = (long)(argv);
-        register long __o2 __asm__ ("o2") = (long)(envp);
-        asm volatile ("t 0x6d\n\t"
-                      "sub %%g0, %%o0, %0\n\t"
-                      "movcc %%xcc, %%o0, %0\n\t"
-                      : "=r" (__res), "=&r" (__o0)
-                      : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__g1)
-                      : "cc");
-        return __res;
-}
 asmlinkage long sys_kern_features(void)
 {
        return KERN_FEATURE_MIXED_MODE_STACK;
diff --git a/arch/sparc/kernel/syscalls.S b/arch/sparc/kernel/syscalls.S
index bf2347794e33..e0fed7711a94 100644
--- a/arch/sparc/kernel/syscalls.S
+++ b/arch/sparc/kernel/syscalls.S
@@ -1,23 +1,19 @@
        /* SunOS's execv() call only specifies the argv argument, the
         * environment settings are the same as the calling processes.
         */
-sys_execve:
+sys64_execve:
-        sethi   %hi(sparc_execve), %g1
+        set     sys_execve, %g1
-        ba,pt   %xcc, execve_merge
+        jmpl    %g1, %g0
-         or     %g1, %lo(sparc_execve), %g1
+         flushw
 #ifdef CONFIG_COMPAT
 sunos_execv:
-        stx     %g0, [%sp + PTREGS_OFF + PT_V9_I2]
+        mov     %g0, %o2
 sys32_execve:
-        sethi   %hi(sparc32_execve), %g1
+        set     compat_sys_execve, %g1
-        or      %g1, %lo(sparc32_execve), %g1
-#endif
-execve_merge:
-        flushw
        jmpl    %g1, %g0
-         add    %sp, PTREGS_OFF, %o0
+         flushw
+#endif
        .align  32
 sys_sparc_pipe:
@@ -112,11 +108,16 @@ sys_clone:
 ret_from_syscall:
        /* Clear current_thread_info()->new_child. */
        stb     %g0, [%g6 + TI_NEW_CHILD]
-        ldx     [%g6 + TI_FLAGS], %l0
        call    schedule_tail
         mov    %g7, %o0
+        ldx     [%sp + PTREGS_OFF + PT_V9_I0], %o0
+        brnz,pt %o0, ret_sys_call
+         ldx    [%g6 + TI_FLAGS], %l0
+        ldx     [%sp + PTREGS_OFF + PT_V9_G1], %l1
+        call    %l1
+         ldx    [%sp + PTREGS_OFF + PT_V9_G2], %o0
        ba,pt   %xcc, ret_sys_call
-         ldx    [%sp + PTREGS_OFF + PT_V9_I0], %o0
+         mov    0, %o0
        .globl  sparc_exit_group
        .type   sparc_exit_group,#function
@@ -232,7 +233,6 @@ ret_sys_call:
        ldx     [%sp + PTREGS_OFF + PT_V9_TNPC], %l1 ! pc = npc
 2:
-        stb     %g0, [%g6 + TI_SYS_NOERROR]
        /* System call success, clear Carry condition code. */
        andn    %g3, %g2, %g3
 3:
diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S
index 017b74a63dcb..cdbd9b817751 100644
--- a/arch/sparc/kernel/systbls_64.S
+++ b/arch/sparc/kernel/systbls_64.S
@@ -107,7 +107,7 @@ sys_call_table:
 /*40*/  .word sys_newlstat, sys_dup, sys_sparc_pipe, sys_times, sys_nis_syscall
        .word sys_umount, sys_setgid, sys_getgid, sys_signal, sys_geteuid
 /*50*/  .word sys_getegid, sys_acct, sys_memory_ordering, sys_nis_syscall, sys_ioctl
-        .word sys_reboot, sys_nis_syscall, sys_symlink, sys_readlink, sys_execve
+        .word sys_reboot, sys_nis_syscall, sys_symlink, sys_readlink, sys64_execve
 /*60*/  .word sys_umask, sys_chroot, sys_newfstat, sys_fstat64, sys_getpagesize
        .word sys_msync, sys_vfork, sys_pread64, sys_pwrite64, sys_nis_syscall
 /*70*/  .word sys_nis_syscall, sys_mmap, sys_nis_syscall, sys_64_munmap, sys_mprotect
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index b66a77968f35..e7ecf1507d90 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -2688,8 +2688,8 @@ void __init trap_init(void)
                     TI_PRE_COUNT != offsetof(struct thread_info,
                                              preempt_count) ||
                     TI_NEW_CHILD != offsetof(struct thread_info, new_child) ||
-                     TI_SYS_NOERROR != offsetof(struct thread_info,
+                     TI_CURRENT_DS != offsetof(struct thread_info,
-                                                syscall_noerror) ||
+                                                current_ds) ||
                     TI_RESTART_BLOCK != offsetof(struct thread_info,
                                                  restart_block) ||
                     TI_KUNA_REGS != offsetof(struct thread_info,
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 9e28a118e6a4..85be1ca539b2 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -624,7 +624,7 @@ static void __init inherit_prom_mappings(void)
 void prom_world(int enter)
 {
        if (!enter)
-                set_fs((mm_segment_t) { get_thread_current_ds() });
+                set_fs(get_fs());
        __asm__ __volatile__("flushw");
 }
diff --git a/arch/tile/Kconfig b/arch/tile/Kconfig
index 875d008828b8..ea7f61e8bc9e 100644
--- a/arch/tile/Kconfig
+++ b/arch/tile/Kconfig
@@ -21,6 +21,8 @@ config TILE
        select ARCH_HAVE_NMI_SAFE_CMPXCHG
        select GENERIC_CLOCKEVENTS
        select MODULES_USE_ELF_RELA
+        select GENERIC_KERNEL_THREAD
+        select GENERIC_KERNEL_EXECVE
 # FIXME: investigate whether we need/want these options.
 #       select HAVE_IOREMAP_PROT
diff --git a/arch/tile/include/asm/compat.h b/arch/tile/include/asm/compat.h
index 3063e6fc8daa..ca61fb4296b3 100644
--- a/arch/tile/include/asm/compat.h
+++ b/arch/tile/include/asm/compat.h
@@ -275,18 +275,14 @@ extern int compat_setup_rt_frame(int sig, struct k_sigaction *ka,
 struct compat_sigaction;
 struct compat_siginfo;
 struct compat_sigaltstack;
-long compat_sys_execve(const char __user *path,
-                       compat_uptr_t __user *argv,
-                       compat_uptr_t __user *envp, struct pt_regs *);
 long compat_sys_rt_sigaction(int sig, struct compat_sigaction __user *act,
                             struct compat_sigaction __user *oact,
                             size_t sigsetsize);
 long compat_sys_rt_sigqueueinfo(int pid, int sig,
                                struct compat_siginfo __user *uinfo);
-long compat_sys_rt_sigreturn(struct pt_regs *);
+long compat_sys_rt_sigreturn(void);
 long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
-                            struct compat_sigaltstack __user *uoss_ptr,
+                            struct compat_sigaltstack __user *uoss_ptr);
-                            struct pt_regs *);
 long compat_sys_truncate64(char __user *filename, u32 dummy, u32 low, u32 high);
 long compat_sys_ftruncate64(unsigned int fd, u32 dummy, u32 low, u32 high);
 long compat_sys_pread64(unsigned int fd, char __user *ubuf, size_t count,
@@ -303,12 +299,7 @@ long compat_sys_fallocate(int fd, int mode,
 long compat_sys_sched_rr_get_interval(compat_pid_t pid,
                                      struct compat_timespec __user *interval);
-/* These are the intvec_64.S trampolines. */
+/* Assembly trampoline to avoid clobbering r0. */
-long _compat_sys_execve(const char __user *path,
-                        const compat_uptr_t __user *argv,
-                        const compat_uptr_t __user *envp);
-long _compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
-                            struct compat_sigaltstack __user *uoss_ptr);
 long _compat_sys_rt_sigreturn(void);
 #endif /* _ASM_TILE_COMPAT_H */
diff --git a/arch/tile/include/asm/elf.h b/arch/tile/include/asm/elf.h
index f8ccf08f6934..b73e1039c911 100644
--- a/arch/tile/include/asm/elf.h
+++ b/arch/tile/include/asm/elf.h
@@ -148,6 +148,7 @@ extern int arch_setup_additional_pages(struct linux_binprm *bprm,
 #define compat_start_thread(regs, ip, usp) do { \
                regs->pc = ptr_to_compat_reg((void *)(ip)); \
                regs->sp = ptr_to_compat_reg((void *)(usp)); \
+                single_step_execve();   \
        } while (0)
 /*
diff --git a/arch/tile/include/asm/processor.h b/arch/tile/include/asm/processor.h
index 8c4dd9ff91eb..2b70dfb1442e 100644
--- a/arch/tile/include/asm/processor.h
+++ b/arch/tile/include/asm/processor.h
@@ -211,6 +211,7 @@ static inline void start_thread(struct pt_regs *regs,
 {
        regs->pc = pc;
        regs->sp = usp;
+        single_step_execve();
 }
 /* Free all resources held by a thread. */
@@ -219,8 +220,6 @@ static inline void release_thread(struct task_struct *dead_task)
        /* Nothing for now */
 }
-extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 extern int do_work_pending(struct pt_regs *regs, u32 flags);
@@ -239,6 +238,9 @@ unsigned long get_wchan(struct task_struct *p);
 #define KSTK_TOP(task)  (task_ksp0(task) - STACK_TOP_DELTA)
 #define task_pt_regs(task) \
  ((struct pt_regs *)(task_ksp0(task) - KSTK_PTREGS_GAP) - 1)
+#define current_pt_regs()                                   \
+  ((struct pt_regs *)((stack_pointer | (THREAD_SIZE - 1)) - \
+                      (KSTK_PTREGS_GAP - 1)) - 1)
 #define task_sp(task)   (task_pt_regs(task)->sp)
 #define task_pc(task)   (task_pt_regs(task)->pc)
 /* Aliases for pc and sp (used in fs/proc/array.c) */
diff --git a/arch/tile/include/asm/switch_to.h b/arch/tile/include/asm/switch_to.h
index 1d48c5fee8b7..b8f888cbe6b0 100644
--- a/arch/tile/include/asm/switch_to.h
+++ b/arch/tile/include/asm/switch_to.h
@@ -68,7 +68,10 @@ extern unsigned long get_switch_to_pc(void);
 /* Support function for forking a new task. */
 void ret_from_fork(void);
-/* Called from ret_from_fork() when a new process starts up. */
+/* Support function for forking a new kernel thread. */
+void ret_from_kernel_thread(void *fn, void *arg);
+/* Called from ret_from_xxx() when a new process starts up. */
 struct task_struct *sim_notify_fork(struct task_struct *prev);
 #endif /* !__ASSEMBLY__ */
diff --git a/arch/tile/include/asm/syscalls.h b/arch/tile/include/asm/syscalls.h
index 06f0464cfed9..4c8462a62cb6 100644
--- a/arch/tile/include/asm/syscalls.h
+++ b/arch/tile/include/asm/syscalls.h
@@ -51,8 +51,7 @@ long sys_cacheflush(unsigned long addr, unsigned long len,
 #ifndef __tilegx__
 /* mm/fault.c */
-long sys_cmpxchg_badaddr(unsigned long address, struct pt_regs *);
+long sys_cmpxchg_badaddr(unsigned long address);
-long _sys_cmpxchg_badaddr(unsigned long address);
 #endif
 #ifdef CONFIG_COMPAT
@@ -63,14 +62,16 @@ long sys_truncate64(const char __user *path, loff_t length);
 long sys_ftruncate64(unsigned int fd, loff_t length);
 #endif
+/* Provide versions of standard syscalls that use current_pt_regs(). */
+long sys_rt_sigreturn(void);
+long sys_sigaltstack(const stack_t __user *, stack_t __user *);
+#define sys_rt_sigreturn sys_rt_sigreturn
+#define sys_sigaltstack sys_sigaltstack
 /* These are the intvec*.S trampolines. */
-long _sys_sigaltstack(const stack_t __user *, stack_t __user *);
 long _sys_rt_sigreturn(void);
 long _sys_clone(unsigned long clone_flags, unsigned long newsp,
                void __user *parent_tid, void __user *child_tid);
-long _sys_execve(const char __user *filename,
-                 const char __user *const __user *argv,
-                 const char __user *const __user *envp);
 #include <asm-generic/syscalls.h>
diff --git a/arch/tile/include/asm/unistd.h b/arch/tile/include/asm/unistd.h
index 6e032a0a268e..b51c6ee3cd6c 100644
--- a/arch/tile/include/asm/unistd.h
+++ b/arch/tile/include/asm/unistd.h
@@ -16,4 +16,6 @@
 #define __ARCH_WANT_SYS_LLSEEK
 #endif
 #define __ARCH_WANT_SYS_NEWFSTATAT
+#define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
 #include <uapi/asm/unistd.h>
diff --git a/arch/tile/kernel/compat.c b/arch/tile/kernel/compat.c
index d67459b9ac2a..9cd7cb6041c0 100644
--- a/arch/tile/kernel/compat.c
+++ b/arch/tile/kernel/compat.c
@@ -102,9 +102,7 @@ long compat_sys_sched_rr_get_interval(compat_pid_t pid,
 #define compat_sys_fadvise64_64 sys32_fadvise64_64
 #define compat_sys_readahead sys32_readahead
-/* Call the trampolines to manage pt_regs where necessary. */
+/* Call the assembly trampolines where necessary. */
-#define compat_sys_execve _compat_sys_execve
-#define compat_sys_sigaltstack _compat_sys_sigaltstack
 #define compat_sys_rt_sigreturn _compat_sys_rt_sigreturn
 #define sys_clone _sys_clone
diff --git a/arch/tile/kernel/compat_signal.c b/arch/tile/kernel/compat_signal.c
index 08b4fe1717bb..2e4cc69224a6 100644
--- a/arch/tile/kernel/compat_signal.c
+++ b/arch/tile/kernel/compat_signal.c
@@ -197,8 +197,7 @@ int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 }
 long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
-                            struct compat_sigaltstack __user *uoss_ptr,
+                            struct compat_sigaltstack __user *uoss_ptr)
-                            struct pt_regs *regs)
 {
        stack_t uss, uoss;
        int ret;
@@ -219,7 +218,7 @@ long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
        set_fs(KERNEL_DS);
        ret = do_sigaltstack(uss_ptr ? (stack_t __user __force *)&uss : NULL,
                             (stack_t __user __force *)&uoss,
-                             (unsigned long)compat_ptr(regs->sp));
+                             (unsigned long)compat_ptr(current_pt_regs()->sp));
        set_fs(seg);
        if (ret >= 0 && uoss_ptr)  {
                if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(*uoss_ptr)) ||
@@ -232,8 +231,9 @@ long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
 }
 /* The assembly shim for this function arranges to ignore the return value. */
-long compat_sys_rt_sigreturn(struct pt_regs *regs)
+long compat_sys_rt_sigreturn(void)
 {
+        struct pt_regs *regs = current_pt_regs();
        struct compat_rt_sigframe __user *frame =
                (struct compat_rt_sigframe __user *) compat_ptr(regs->sp);
        sigset_t set;
@@ -248,7 +248,7 @@ long compat_sys_rt_sigreturn(struct pt_regs *regs)
        if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
                goto badframe;
-        if (compat_sys_sigaltstack(&frame->uc.uc_stack, NULL, regs) != 0)
+        if (compat_sys_sigaltstack(&frame->uc.uc_stack, NULL) == -EFAULT)
                goto badframe;
        return 0;
diff --git a/arch/tile/kernel/entry.S b/arch/tile/kernel/entry.S
index c31637baff28..f116cb0bce20 100644
--- a/arch/tile/kernel/entry.S
+++ b/arch/tile/kernel/entry.S
@@ -28,17 +28,6 @@ STD_ENTRY(current_text_addr)
        STD_ENDPROC(current_text_addr)
 /*
- * Implement execve().  The i386 code has a note that forking from kernel
- * space results in no copy on write until the execve, so we should be
- * careful not to write to the stack here.
- */
-STD_ENTRY(kernel_execve)
-        moveli TREG_SYSCALL_NR_NAME, __NR_execve
-        swint1
-        jrp lr
-        STD_ENDPROC(kernel_execve)
-/*
 * We don't run this function directly, but instead copy it to a page
 * we map into every user process.  See vdso_setup().
 *
diff --git a/arch/tile/kernel/intvec_32.S b/arch/tile/kernel/intvec_32.S
index 6943515100f8..f212bf7cea86 100644
--- a/arch/tile/kernel/intvec_32.S
+++ b/arch/tile/kernel/intvec_32.S
@@ -1291,6 +1291,21 @@ STD_ENTRY(ret_from_fork)
        }
        STD_ENDPROC(ret_from_fork)
+STD_ENTRY(ret_from_kernel_thread)
+        jal     sim_notify_fork
+        jal     schedule_tail
+        FEEDBACK_REENTER(ret_from_fork)
+        {
+         move   r0, r31
+         jalr   r30
+        }
+        FEEDBACK_REENTER(ret_from_kernel_thread)
+        {
+         movei  r30, 0               /* not an NMI */
+         j      .Lresume_userspace   /* jump into middle of interrupt_return */
+        }
+        STD_ENDPROC(ret_from_kernel_thread)
        /*
         * Code for ill interrupt.
         */
@@ -1437,15 +1452,6 @@ STD_ENTRY_LOCAL(bad_intr)
        panic   "Unhandled interrupt %#x: PC %#lx"
        STD_ENDPROC(bad_intr)
-/* Put address of pt_regs in reg and jump. */
-#define PTREGS_SYSCALL(x, reg)                          \
-        STD_ENTRY(_##x);                                \
-        {                                               \
-         PTREGS_PTR(reg, PTREGS_OFFSET_BASE);           \
-         j      x                                       \
-        };                                              \
-        STD_ENDPROC(_##x)
 /*
 * Special-case sigreturn to not write r0 to the stack on return.
 * This is technically more efficient, but it also avoids difficulties
@@ -1461,12 +1467,9 @@ STD_ENTRY_LOCAL(bad_intr)
        };                                              \
        STD_ENDPROC(_##x)
-PTREGS_SYSCALL(sys_execve, r3)
-PTREGS_SYSCALL(sys_sigaltstack, r2)
 PTREGS_SYSCALL_SIGRETURN(sys_rt_sigreturn, r0)
-PTREGS_SYSCALL(sys_cmpxchg_badaddr, r1)
-/* Save additional callee-saves to pt_regs, put address in r4 and jump. */
+/* Save additional callee-saves to pt_regs and jump to standard function. */
 STD_ENTRY(_sys_clone)
        push_extra_callee_saves r4
        j       sys_clone
diff --git a/arch/tile/kernel/intvec_64.S b/arch/tile/kernel/intvec_64.S
index 7c06d597ffd0..54bc9a6678e8 100644
--- a/arch/tile/kernel/intvec_64.S
+++ b/arch/tile/kernel/intvec_64.S
@@ -1150,6 +1150,21 @@ STD_ENTRY(ret_from_fork)
        }
        STD_ENDPROC(ret_from_fork)
+STD_ENTRY(ret_from_kernel_thread)
+        jal     sim_notify_fork
+        jal     schedule_tail
+        FEEDBACK_REENTER(ret_from_fork)
+        {
+         move   r0, r31
+         jalr   r30
+        }
+        FEEDBACK_REENTER(ret_from_kernel_thread)
+        {
+         movei  r30, 0               /* not an NMI */
+         j      .Lresume_userspace   /* jump into middle of interrupt_return */
+        }
+        STD_ENDPROC(ret_from_kernel_thread)
 /* Various stub interrupt handlers and syscall handlers */
 STD_ENTRY_LOCAL(_kernel_double_fault)
@@ -1166,15 +1181,6 @@ STD_ENTRY_LOCAL(bad_intr)
        panic   "Unhandled interrupt %#x: PC %#lx"
        STD_ENDPROC(bad_intr)
-/* Put address of pt_regs in reg and jump. */
-#define PTREGS_SYSCALL(x, reg)                          \
-        STD_ENTRY(_##x);                                \
-        {                                               \
-         PTREGS_PTR(reg, PTREGS_OFFSET_BASE);           \
-         j      x                                       \
-        };                                              \
-        STD_ENDPROC(_##x)
 /*
 * Special-case sigreturn to not write r0 to the stack on return.
 * This is technically more efficient, but it also avoids difficulties
@@ -1190,16 +1196,12 @@ STD_ENTRY_LOCAL(bad_intr)
        };                                              \
        STD_ENDPROC(_##x)
-PTREGS_SYSCALL(sys_execve, r3)
-PTREGS_SYSCALL(sys_sigaltstack, r2)
 PTREGS_SYSCALL_SIGRETURN(sys_rt_sigreturn, r0)
 #ifdef CONFIG_COMPAT
-PTREGS_SYSCALL(compat_sys_execve, r3)
-PTREGS_SYSCALL(compat_sys_sigaltstack, r2)
 PTREGS_SYSCALL_SIGRETURN(compat_sys_rt_sigreturn, r0)
 #endif
-/* Save additional callee-saves to pt_regs, put address in r4 and jump. */
+/* Save additional callee-saves to pt_regs and jump to standard function. */
 STD_ENTRY(_sys_clone)
        push_extra_callee_saves r4
        j       sys_clone
diff --git a/arch/tile/kernel/process.c b/arch/tile/kernel/process.c
index 307d010696c9..0e5661e7d00d 100644
--- a/arch/tile/kernel/process.c
+++ b/arch/tile/kernel/process.c
@@ -157,24 +157,43 @@ void arch_release_thread_info(struct thread_info *info)
 static void save_arch_state(struct thread_struct *t);
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-                unsigned long stack_size,
+                unsigned long arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs *childregs;
+        struct pt_regs *childregs = task_pt_regs(p), *regs = current_pt_regs();
        unsigned long ksp;
+        unsigned long *callee_regs;
        /*
-         * When creating a new kernel thread we pass sp as zero.
+         * Set up the stack and stack pointer appropriately for the
-         * Assign it to a reasonable value now that we have the stack.
+         * new child to find itself woken up in __switch_to().
+         * The callee-saved registers must be on the stack to be read;
+         * the new task will then jump to assembly support to handle
+         * calling schedule_tail(), etc., and (for userspace tasks)
+         * returning to the context set up in the pt_regs.
         */
-        if (sp == 0 && regs->ex1 == PL_ICS_EX1(KERNEL_PL, 0))
+        ksp = (unsigned long) childregs;
-                sp = KSTK_TOP(p);
+        ksp -= C_ABI_SAVE_AREA_SIZE;   /* interrupt-entry save area */
+        ((long *)ksp)[0] = ((long *)ksp)[1] = 0;
+        ksp -= CALLEE_SAVED_REGS_COUNT * sizeof(unsigned long);
+        callee_regs = (unsigned long *)ksp;
+        ksp -= C_ABI_SAVE_AREA_SIZE;   /* __switch_to() save area */
+        ((long *)ksp)[0] = ((long *)ksp)[1] = 0;
+        p->thread.ksp = ksp;
-        /*
+        /* Record the pid of the task that created this one. */
-         * Do not clone step state from the parent; each thread
+        p->thread.creator_pid = current->pid;
-         * must make its own lazily.
-         */
+        if (unlikely(p->flags & PF_KTHREAD)) {
-        task_thread_info(p)->step_state = NULL;
+                /* kernel thread */
+                memset(childregs, 0, sizeof(struct pt_regs));
+                memset(&callee_regs[2], 0,
+                       (CALLEE_SAVED_REGS_COUNT - 2) * sizeof(unsigned long));
+                callee_regs[0] = sp;   /* r30 = function */
+                callee_regs[1] = arg;  /* r31 = arg */
+                childregs->ex1 = PL_ICS_EX1(KERNEL_PL, 0);
+                p->thread.pc = (unsigned long) ret_from_kernel_thread;
+                return 0;
+        }
        /*
         * Start new thread in ret_from_fork so it schedules properly
@@ -182,46 +201,33 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
         */
        p->thread.pc = (unsigned long) ret_from_fork;
-        /* Save user stack top pointer so we can ID the stack vm area later. */
+        /*
-        p->thread.usp0 = sp;
+         * Do not clone step state from the parent; each thread
+         * must make its own lazily.
-        /* Record the pid of the process that created this one. */
+         */
-        p->thread.creator_pid = current->pid;
+        task_thread_info(p)->step_state = NULL;
        /*
         * Copy the registers onto the kernel stack so the
         * return-from-interrupt code will reload it into registers.
         */
-        childregs = task_pt_regs(p);
+        *childregs = *current_pt_regs();
-        *childregs = *regs;
        childregs->regs[0] = 0;         /* return value is zero */
-        childregs->sp = sp;  /* override with new user stack pointer */
+        if (sp)
+                childregs->sp = sp;  /* override with new user stack pointer */
+        memcpy(callee_regs, &childregs->regs[CALLEE_SAVED_FIRST_REG],
+               CALLEE_SAVED_REGS_COUNT * sizeof(unsigned long));
+        /* Save user stack top pointer so we can ID the stack vm area later. */
+        p->thread.usp0 = childregs->sp;
        /*
         * If CLONE_SETTLS is set, set "tp" in the new task to "r4",
         * which is passed in as arg #5 to sys_clone().
         */
        if (clone_flags & CLONE_SETTLS)
-                childregs->tp = regs->regs[4];
+                childregs->tp = childregs->regs[4];
-        /*
-         * Copy the callee-saved registers from the passed pt_regs struct
-         * into the context-switch callee-saved registers area.
-         * This way when we start the interrupt-return sequence, the
-         * callee-save registers will be correctly in registers, which
-         * is how we assume the compiler leaves them as we start doing
-         * the normal return-from-interrupt path after calling C code.
-         * Zero out the C ABI save area to mark the top of the stack.
-         */
-        ksp = (unsigned long) childregs;
-        ksp -= C_ABI_SAVE_AREA_SIZE;   /* interrupt-entry save area */
-        ((long *)ksp)[0] = ((long *)ksp)[1] = 0;
-        ksp -= CALLEE_SAVED_REGS_COUNT * sizeof(unsigned long);
-        memcpy((void *)ksp, &regs->regs[CALLEE_SAVED_FIRST_REG],
-               CALLEE_SAVED_REGS_COUNT * sizeof(unsigned long));
-        ksp -= C_ABI_SAVE_AREA_SIZE;   /* __switch_to() save area */
-        ((long *)ksp)[0] = ((long *)ksp)[1] = 0;
-        p->thread.ksp = ksp;
 #if CHIP_HAS_TILE_DMA()
        /*
@@ -577,62 +583,6 @@ int do_work_pending(struct pt_regs *regs, u32 thread_info_flags)
        panic("work_pending: bad flags %#x\n", thread_info_flags);
 }
-/* Note there is an implicit fifth argument if (clone_flags & CLONE_SETTLS). */
-SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
-                void __user *, parent_tidptr, void __user *, child_tidptr,
-                struct pt_regs *, regs)
-{
-        if (!newsp)
-                newsp = regs->sp;
-        return do_fork(clone_flags, newsp, regs, 0,
-                       parent_tidptr, child_tidptr);
-}
-/*
- * sys_execve() executes a new program.
- */
-SYSCALL_DEFINE4(execve, const char __user *, path,
-                const char __user *const __user *, argv,
-                const char __user *const __user *, envp,
-                struct pt_regs *, regs)
-{
-        long error;
-        struct filename *filename;
-        filename = getname(path);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-        if (error == 0)
-                single_step_execve();
-out:
-        return error;
-}
-#ifdef CONFIG_COMPAT
-long compat_sys_execve(const char __user *path,
-                       compat_uptr_t __user *argv,
-                       compat_uptr_t __user *envp,
-                       struct pt_regs *regs)
-{
-        long error;
-        struct filename *filename;
-        filename = getname(path);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = compat_do_execve(filename->name, argv, envp, regs);
-        putname(filename);
-        if (error == 0)
-                single_step_execve();
-out:
-        return error;
-}
-#endif
 unsigned long get_wchan(struct task_struct *p)
 {
        struct KBacktraceIterator kbt;
@@ -650,37 +600,6 @@ unsigned long get_wchan(struct task_struct *p)
        return 0;
 }
-/*
- * We pass in lr as zero (cleared in kernel_thread) and the caller
- * part of the backtrace ABI on the stack also zeroed (in copy_thread)
- * so that backtraces will stop with this function.
- * Note that we don't use r0, since copy_thread() clears it.
- */
-static void start_kernel_thread(int dummy, int (*fn)(int), int arg)
-{
-        do_exit(fn(arg));
-}
-/*
- * Create a kernel thread
- */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-        struct pt_regs regs;
-        memset(&regs, 0, sizeof(regs));
-        regs.ex1 = PL_ICS_EX1(KERNEL_PL, 0);  /* run at kernel PL, no ICS */
-        regs.pc = (long) start_kernel_thread;
-        regs.flags = PT_FLAGS_CALLER_SAVES;   /* need to restore r1 and r2 */
-        regs.regs[1] = (long) fn;             /* function pointer */
-        regs.regs[2] = (long) arg;            /* parameter register */
-        /* Ok, create the new process.. */
-        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs,
-                       0, NULL, NULL);
-}
-EXPORT_SYMBOL(kernel_thread);
 /* Flush thread state. */
 void flush_thread(void)
 {
diff --git a/arch/tile/kernel/signal.c b/arch/tile/kernel/signal.c
index 67efb656d104..657a7ace4ab4 100644
--- a/arch/tile/kernel/signal.c
+++ b/arch/tile/kernel/signal.c
@@ -37,10 +37,10 @@
 #define DEBUG_SIG 0
-SYSCALL_DEFINE3(sigaltstack, const stack_t __user *, uss,
+SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
-                stack_t __user *, uoss, struct pt_regs *, regs)
+                stack_t __user *, uoss)
 {
-        return do_sigaltstack(uss, uoss, regs->sp);
+        return do_sigaltstack(uss, uoss, current_pt_regs()->sp);
 }
@@ -83,8 +83,9 @@ void signal_fault(const char *type, struct pt_regs *regs,
 }
 /* The assembly shim for this function arranges to ignore the return value. */
-SYSCALL_DEFINE1(rt_sigreturn, struct pt_regs *, regs)
+SYSCALL_DEFINE0(rt_sigreturn)
 {
+        struct pt_regs *regs = current_pt_regs();
        struct rt_sigframe __user *frame =
                (struct rt_sigframe __user *)(regs->sp);
        sigset_t set;
diff --git a/arch/tile/kernel/sys.c b/arch/tile/kernel/sys.c
index b08095b402d6..b881a7be24bd 100644
--- a/arch/tile/kernel/sys.c
+++ b/arch/tile/kernel/sys.c
@@ -106,14 +106,10 @@ SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
 #define sys_readahead sys32_readahead
 #endif
-/* Call the trampolines to manage pt_regs where necessary. */
+/* Call the assembly trampolines where necessary. */
-#define sys_execve _sys_execve
+#undef sys_rt_sigreturn
-#define sys_sigaltstack _sys_sigaltstack
 #define sys_rt_sigreturn _sys_rt_sigreturn
 #define sys_clone _sys_clone
-#ifndef __tilegx__
-#define sys_cmpxchg_badaddr _sys_cmpxchg_badaddr
-#endif
 /*
 * Note that we can't include <linux/unistd.h> here since the header
diff --git a/arch/tile/mm/fault.c b/arch/tile/mm/fault.c
index fe811fa5f1b9..3d2b81c163a6 100644
--- a/arch/tile/mm/fault.c
+++ b/arch/tile/mm/fault.c
@@ -70,9 +70,10 @@ static noinline void force_sig_info_fault(const char *type, int si_signo,
 * Synthesize the fault a PL0 process would get by doing a word-load of
 * an unaligned address or a high kernel address.
 */
-SYSCALL_DEFINE2(cmpxchg_badaddr, unsigned long, address,
+SYSCALL_DEFINE1(cmpxchg_badaddr, unsigned long, address)
-                struct pt_regs *, regs)
 {
+        struct pt_regs *regs = current_pt_regs();
        if (address >= PAGE_OFFSET)
                force_sig_info_fault("atomic segfault", SIGSEGV, SEGV_MAPERR,
                                     address, INT_DTLB_MISS, current, regs);
diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index b6d699cdd557..b462b13c5bae 100644
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -161,8 +161,7 @@ void fork_handler(void)
 }
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-                unsigned long arg, struct task_struct * p,
+                unsigned long arg, struct task_struct * p)
-                struct pt_regs *regs)
 {
        void (*handler)(void);
        int kthread = current->flags & PF_KTHREAD;
@@ -171,7 +170,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
        p->thread = (struct thread_struct) INIT_THREAD;
        if (!kthread) {
-                memcpy(&p->thread.regs.regs, &regs->regs,
+                memcpy(&p->thread.regs.regs, current_pt_regs(),
                       sizeof(p->thread.regs.regs));
                PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0);
                if (sp != 0)
diff --git a/arch/um/kernel/syscall.c b/arch/um/kernel/syscall.c
index a81f3705e90f..c1d0ae069b53 100644
--- a/arch/um/kernel/syscall.c
+++ b/arch/um/kernel/syscall.c
@@ -14,29 +14,6 @@
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
-long sys_fork(void)
-{
-        return do_fork(SIGCHLD, UPT_SP(&current->thread.regs.regs),
-                      &current->thread.regs, 0, NULL, NULL);
-}
-long sys_vfork(void)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
-                      UPT_SP(&current->thread.regs.regs),
-                      &current->thread.regs, 0, NULL, NULL);
-}
-long sys_clone(unsigned long clone_flags, unsigned long newsp,
-               void __user *parent_tid, void __user *child_tid)
-{
-        if (!newsp)
-                newsp = UPT_SP(&current->thread.regs.regs);
-        return do_fork(clone_flags, newsp, &current->thread.regs, 0, parent_tid,
-                      child_tid);
-}
 long old_mmap(unsigned long addr, unsigned long len,
              unsigned long prot, unsigned long flags,
              unsigned long fd, unsigned long offset)
diff --git a/arch/unicore32/include/uapi/asm/unistd.h b/arch/unicore32/include/uapi/asm/unistd.h
index d18a3be89b38..00cf5e286fca 100644
--- a/arch/unicore32/include/uapi/asm/unistd.h
+++ b/arch/unicore32/include/uapi/asm/unistd.h
@@ -13,3 +13,4 @@
 /* Use the standard ABI for syscalls. */
 #include <asm-generic/unistd.h>
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
diff --git a/arch/unicore32/kernel/entry.S b/arch/unicore32/kernel/entry.S
index 7049350c790f..581630d91444 100644
--- a/arch/unicore32/kernel/entry.S
+++ b/arch/unicore32/kernel/entry.S
@@ -668,12 +668,6 @@ __cr_alignment:
 #endif
        .ltorg
-ENTRY(sys_clone)
-                add     ip, sp, #S_OFF
-                stw     ip, [sp+], #4
-                b       __sys_clone
-ENDPROC(sys_clone)
 ENTRY(sys_rt_sigreturn)
                add     r0, sp, #S_OFF
                mov     why, #0         @ prevent syscall restart handling
diff --git a/arch/unicore32/kernel/process.c b/arch/unicore32/kernel/process.c
index a8fe265ce2c0..62bad9fed03e 100644
--- a/arch/unicore32/kernel/process.c
+++ b/arch/unicore32/kernel/process.c
@@ -262,26 +262,27 @@ asmlinkage void ret_from_kernel_thread(void) __asm__("ret_from_kernel_thread");
 int
 copy_thread(unsigned long clone_flags, unsigned long stack_start,
-            unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
+            unsigned long stk_sz, struct task_struct *p)
 {
        struct thread_info *thread = task_thread_info(p);
        struct pt_regs *childregs = task_pt_regs(p);
        memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
        thread->cpu_context.sp = (unsigned long)childregs;
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                thread->cpu_context.pc = (unsigned long)ret_from_kernel_thread;
                thread->cpu_context.r4 = stack_start;
                thread->cpu_context.r5 = stk_sz;
                memset(childregs, 0, sizeof(struct pt_regs));
        } else {
                thread->cpu_context.pc = (unsigned long)ret_from_fork;
-                *childregs = *regs;
+                *childregs = *current_pt_regs();
                childregs->UCreg_00 = 0;
-                childregs->UCreg_sp = stack_start;
+                if (stack_start)
+                        childregs->UCreg_sp = stack_start;
                if (clone_flags & CLONE_SETTLS)
-                        childregs->UCreg_16 = regs->UCreg_03;
+                        childregs->UCreg_16 = childregs->UCreg_03;
        }
        return 0;
 }
diff --git a/arch/unicore32/kernel/sys.c b/arch/unicore32/kernel/sys.c
index 9680134b31f0..cfe79c9529b3 100644
--- a/arch/unicore32/kernel/sys.c
+++ b/arch/unicore32/kernel/sys.c
@@ -28,20 +28,6 @@
 #include <asm/syscalls.h>
 #include <asm/cacheflush.h>
-/* Clone a task - this clones the calling program thread.
- * This is called indirectly via a small wrapper
- */
-asmlinkage long __sys_clone(unsigned long clone_flags, unsigned long newsp,
-                         void __user *parent_tid, void __user *child_tid,
-                         struct pt_regs *regs)
-{
-        if (!newsp)
-                newsp = regs->UCreg_sp;
-        return do_fork(clone_flags, newsp, regs, 0,
-                        parent_tid, child_tid);
-}
 /* Note: used by the compat code even in 64-bit Linux. */
 SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len,
                unsigned long, prot, unsigned long, flags,
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 037c4e30c271..9195fd80e11e 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -112,6 +112,7 @@ config X86
        select GENERIC_KERNEL_EXECVE
        select MODULES_USE_ELF_REL if X86_32
        select MODULES_USE_ELF_RELA if X86_64
+        select CLONE_BACKWARDS if X86_32
 config INSTRUCTION_DECODER
        def_bool y
diff --git a/arch/x86/ia32/ia32_aout.c b/arch/x86/ia32/ia32_aout.c
index 07b3a68d2d29..a703af19c281 100644
--- a/arch/x86/ia32/ia32_aout.c
+++ b/arch/x86/ia32/ia32_aout.c
@@ -35,7 +35,7 @@
 #undef WARN_OLD
 #undef CORE_DUMP /* definitely broken */
-static int load_aout_binary(struct linux_binprm *, struct pt_regs *regs);
+static int load_aout_binary(struct linux_binprm *);
 static int load_aout_library(struct file *);
 #ifdef CORE_DUMP
@@ -260,9 +260,10 @@ static u32 __user *create_aout_tables(char __user *p, struct linux_binprm *bprm)
 * These are the functions used to load a.out style executables and shared
 * libraries.  There is no binary dependent code anywhere else.
 */
-static int load_aout_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+static int load_aout_binary(struct linux_binprm *bprm)
 {
        unsigned long error, fd_offset, rlim;
+        struct pt_regs *regs = current_pt_regs();
        struct exec ex;
        int retval;
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index 076745fc8045..32e6f05ddaaa 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -467,11 +467,16 @@ GLOBAL(\label)
        PTREGSCALL stub32_sigaltstack, sys32_sigaltstack, %rdx
        PTREGSCALL stub32_execve, compat_sys_execve, %rcx
        PTREGSCALL stub32_fork, sys_fork, %rdi
-        PTREGSCALL stub32_clone, sys32_clone, %rdx
        PTREGSCALL stub32_vfork, sys_vfork, %rdi
        PTREGSCALL stub32_iopl, sys_iopl, %rsi
        ALIGN
+GLOBAL(stub32_clone)
+        leaq sys_clone(%rip),%rax
+        mov     %r8, %rcx
+        jmp  ia32_ptregs_common 
+        ALIGN
 ia32_ptregs_common:
        popq %r11
        CFI_ENDPROC
diff --git a/arch/x86/ia32/sys_ia32.c b/arch/x86/ia32/sys_ia32.c
index 86d68d1c8806..d0b689ba7be2 100644
--- a/arch/x86/ia32/sys_ia32.c
+++ b/arch/x86/ia32/sys_ia32.c
@@ -385,17 +385,6 @@ asmlinkage long sys32_sendfile(int out_fd, int in_fd,
        return ret;
 }
-asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
-                            struct pt_regs *regs)
-{
-        void __user *parent_tid = (void __user *)regs->dx;
-        void __user *child_tid = (void __user *)regs->di;
-        if (!newsp)
-                newsp = regs->sp;
-        return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
-}
 /*
 * Some system calls that need sign extended arguments. This could be
 * done by a generic wrapper.
diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
index e101b38912de..888184b2fc85 100644
--- a/arch/x86/include/asm/processor.h
+++ b/arch/x86/include/asm/processor.h
@@ -178,8 +178,6 @@ static inline int hlt_works(int cpu)
 extern void cpu_detect(struct cpuinfo_x86 *c);
-extern struct pt_regs *idle_regs(struct pt_regs *);
 extern void early_cpu_init(void);
 extern void identify_boot_cpu(void);
 extern void identify_secondary_cpu(struct cpuinfo_x86 *);
diff --git a/arch/x86/include/asm/signal.h b/arch/x86/include/asm/signal.h
index 323973f4abf1..0dba8b7a6ac7 100644
--- a/arch/x86/include/asm/signal.h
+++ b/arch/x86/include/asm/signal.h
@@ -260,8 +260,6 @@ struct pt_regs;
 #endif /* !__i386__ */
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
diff --git a/arch/x86/include/asm/sys_ia32.h b/arch/x86/include/asm/sys_ia32.h
index a9a8cf3da49d..c76fae4d90be 100644
--- a/arch/x86/include/asm/sys_ia32.h
+++ b/arch/x86/include/asm/sys_ia32.h
@@ -54,8 +54,6 @@ asmlinkage long sys32_pwrite(unsigned int, const char __user *, u32, u32, u32);
 asmlinkage long sys32_personality(unsigned long);
 asmlinkage long sys32_sendfile(int, int, compat_off_t __user *, s32);
-asmlinkage long sys32_clone(unsigned int, unsigned int, struct pt_regs *);
 long sys32_lseek(unsigned int, int, unsigned int);
 long sys32_kill(int, int);
 long sys32_fadvise64_64(int, __u32, __u32, __u32, __u32, int);
diff --git a/arch/x86/include/asm/syscalls.h b/arch/x86/include/asm/syscalls.h
index 2be0b880417e..2f8374718aa3 100644
--- a/arch/x86/include/asm/syscalls.h
+++ b/arch/x86/include/asm/syscalls.h
@@ -20,15 +20,6 @@
 asmlinkage long sys_ioperm(unsigned long, unsigned long, int);
 long sys_iopl(unsigned int, struct pt_regs *);
-/* kernel/process.c */
-int sys_fork(struct pt_regs *);
-int sys_vfork(struct pt_regs *);
-long sys_execve(const char __user *,
-                const char __user *const __user *,
-                const char __user *const __user *);
-long sys_clone(unsigned long, unsigned long, void __user *,
-               void __user *, struct pt_regs *);
 /* kernel/ldt.c */
 asmlinkage int sys_modify_ldt(int, void __user *, unsigned long);
diff --git a/arch/x86/include/asm/unistd.h b/arch/x86/include/asm/unistd.h
index 16f3fc6ebf2e..0e7dea7d3669 100644
--- a/arch/x86/include/asm/unistd.h
+++ b/arch/x86/include/asm/unistd.h
@@ -51,6 +51,9 @@
 # define __ARCH_WANT_SYS_UTIME
 # define __ARCH_WANT_SYS_WAITPID
 # define __ARCH_WANT_SYS_EXECVE
+# define __ARCH_WANT_SYS_FORK
+# define __ARCH_WANT_SYS_VFORK
+# define __ARCH_WANT_SYS_CLONE
 /*
 * "Conditional" syscalls
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index ca165ac6793b..9c3ab43a6954 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -1173,15 +1173,6 @@ DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);
 DEFINE_PER_CPU_ALIGNED(struct stack_canary, stack_canary);
 #endif
-/* Make sure %fs and %gs are initialized properly in idle threads */
-struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
-{
-        memset(regs, 0, sizeof(struct pt_regs));
-        regs->fs = __KERNEL_PERCPU;
-        regs->gs = __KERNEL_STACK_CANARY;
-        return regs;
-}
 #endif  /* CONFIG_X86_64 */
 /*
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S
index 88b725aa1d52..c763116c5359 100644
--- a/arch/x86/kernel/entry_32.S
+++ b/arch/x86/kernel/entry_32.S
@@ -739,30 +739,12 @@ ENTRY(ptregs_##name) ; \
 ENDPROC(ptregs_##name)
 PTREGSCALL1(iopl)
-PTREGSCALL0(fork)
-PTREGSCALL0(vfork)
 PTREGSCALL2(sigaltstack)
 PTREGSCALL0(sigreturn)
 PTREGSCALL0(rt_sigreturn)
 PTREGSCALL2(vm86)
 PTREGSCALL1(vm86old)
-/* Clone is an oddball.  The 4th arg is in %edi */
-ENTRY(ptregs_clone)
-        CFI_STARTPROC
-        leal 4(%esp),%eax
-        pushl_cfi %eax
-        pushl_cfi PT_EDI(%eax)
-        movl PT_EDX(%eax),%ecx
-        movl PT_ECX(%eax),%edx
-        movl PT_EBX(%eax),%eax
-        call sys_clone
-        addl $8,%esp
-        CFI_ADJUST_CFA_OFFSET -8
-        ret
-        CFI_ENDPROC
-ENDPROC(ptregs_clone)
 .macro FIXUP_ESPFIX_STACK
 /*
 * Switch back for ESPFIX stack to the normal zerobased stack
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index 31b46128a63d..70641aff0c25 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -845,9 +845,25 @@ ENTRY(\label)
 END(\label)
        .endm
-        PTREGSCALL stub_clone, sys_clone, %r8
+        .macro FORK_LIKE func
-        PTREGSCALL stub_fork, sys_fork, %rdi
+ENTRY(stub_\func)
-        PTREGSCALL stub_vfork, sys_vfork, %rdi
+        CFI_STARTPROC
+        popq    %r11                    /* save return address */
+        PARTIAL_FRAME 0
+        SAVE_REST
+        pushq   %r11                    /* put it back on stack */
+        FIXUP_TOP_OF_STACK %r11, 8
+        DEFAULT_FRAME 0 8               /* offset 8: return address */
+        call sys_\func
+        RESTORE_TOP_OF_STACK %r11, 8
+        ret $REST_SKIP          /* pop extended registers */
+        CFI_ENDPROC
+END(stub_\func)
+        .endm
+        FORK_LIKE  clone
+        FORK_LIKE  fork
+        FORK_LIKE  vfork
        PTREGSCALL stub_sigaltstack, sys_sigaltstack, %rdx
        PTREGSCALL stub_iopl, sys_iopl, %rsi
diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c
index 2f99e3121875..2ed787f15bf0 100644
--- a/arch/x86/kernel/process.c
+++ b/arch/x86/kernel/process.c
@@ -262,36 +262,6 @@ void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
        propagate_user_return_notify(prev_p, next_p);
 }
-int sys_fork(struct pt_regs *regs)
-{
-        return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
-}
-/*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
-int sys_vfork(struct pt_regs *regs)
-{
-        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
-                       NULL, NULL);
-}
-long
-sys_clone(unsigned long clone_flags, unsigned long newsp,
-          void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
-{
-        if (!newsp)
-                newsp = regs->sp;
-        return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
-}
 /*
 * Idle related variables and functions
 */
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index 44e0bff38e72..b5a8905785e6 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -128,8 +128,7 @@ void release_thread(struct task_struct *dead_task)
 }
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-        unsigned long arg,
+        unsigned long arg, struct task_struct *p)
-        struct task_struct *p, struct pt_regs *regs)
 {
        struct pt_regs *childregs = task_pt_regs(p);
        struct task_struct *tsk;
@@ -138,7 +137,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
        p->thread.sp = (unsigned long) childregs;
        p->thread.sp0 = (unsigned long) (childregs+1);
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* kernel thread */
                memset(childregs, 0, sizeof(struct pt_regs));
                p->thread.ip = (unsigned long) ret_from_kernel_thread;
@@ -156,12 +155,13 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
                return 0;
        }
-        *childregs = *regs;
+        *childregs = *current_pt_regs();
        childregs->ax = 0;
-        childregs->sp = sp;
+        if (sp)
+                childregs->sp = sp;
        p->thread.ip = (unsigned long) ret_from_fork;
-        task_user_gs(p) = get_user_gs(regs);
+        task_user_gs(p) = get_user_gs(current_pt_regs());
        p->fpu_counter = 0;
        p->thread.io_bitmap_ptr = NULL;
diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
index 16c6365e2b86..6e68a6194965 100644
--- a/arch/x86/kernel/process_64.c
+++ b/arch/x86/kernel/process_64.c
@@ -146,8 +146,7 @@ static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 }
 int copy_thread(unsigned long clone_flags, unsigned long sp,
-                unsigned long arg,
+                unsigned long arg, struct task_struct *p)
-        struct task_struct *p, struct pt_regs *regs)
 {
        int err;
        struct pt_regs *childregs;
@@ -169,7 +168,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
        savesegment(ds, p->thread.ds);
        memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
-        if (unlikely(!regs)) {
+        if (unlikely(p->flags & PF_KTHREAD)) {
                /* kernel thread */
                memset(childregs, 0, sizeof(struct pt_regs));
                childregs->sp = (unsigned long)childregs;
@@ -181,10 +180,11 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_BIT1;
                return 0;
        }
-        *childregs = *regs;
+        *childregs = *current_pt_regs();
        childregs->ax = 0;
-        childregs->sp = sp;
+        if (sp)
+                childregs->sp = sp;
        err = -ENOMEM;
        memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
diff --git a/arch/x86/syscalls/syscall_32.tbl b/arch/x86/syscalls/syscall_32.tbl
index a47103fbc692..ee3c220ee500 100644
--- a/arch/x86/syscalls/syscall_32.tbl
+++ b/arch/x86/syscalls/syscall_32.tbl
@@ -8,7 +8,7 @@
 #
 0       i386    restart_syscall         sys_restart_syscall
 1       i386    exit                    sys_exit
-2       i386    fork                    ptregs_fork                     stub32_fork
+2       i386    fork                    sys_fork                        stub32_fork
 3       i386    read                    sys_read
 4       i386    write                   sys_write
 5       i386    open                    sys_open                        compat_sys_open
@@ -126,7 +126,7 @@
 117     i386    ipc                     sys_ipc                         sys32_ipc
 118     i386    fsync                   sys_fsync
 119     i386    sigreturn               ptregs_sigreturn                stub32_sigreturn
-120     i386    clone                   ptregs_clone                    stub32_clone
+120     i386    clone                   sys_clone                       stub32_clone
 121     i386    setdomainname           sys_setdomainname
 122     i386    uname                   sys_newuname
 123     i386    modify_ldt              sys_modify_ldt
@@ -196,7 +196,7 @@
 187     i386    sendfile                sys_sendfile                    sys32_sendfile
 188     i386    getpmsg
 189     i386    putpmsg
-190     i386    vfork                   ptregs_vfork                    stub32_vfork
+190     i386    vfork                   sys_vfork                       stub32_vfork
 191     i386    ugetrlimit              sys_getrlimit                   compat_sys_getrlimit
 192     i386    mmap2                   sys_mmap_pgoff
 193     i386    truncate64              sys_truncate64                  sys32_truncate64
diff --git a/arch/x86/um/Kconfig b/arch/x86/um/Kconfig
index b0c30dae9f55..983997041963 100644
--- a/arch/x86/um/Kconfig
+++ b/arch/x86/um/Kconfig
@@ -25,6 +25,7 @@ config X86_32
        select HAVE_AOUT
        select ARCH_WANT_IPC_PARSE_VERSION
        select MODULES_USE_ELF_REL
+        select CLONE_BACKWARDS
 config X86_64
        def_bool 64BIT
diff --git a/arch/x86/um/shared/sysdep/syscalls.h b/arch/x86/um/shared/sysdep/syscalls.h
index ca255a805ed9..bd9a89b67e41 100644
--- a/arch/x86/um/shared/sysdep/syscalls.h
+++ b/arch/x86/um/shared/sysdep/syscalls.h
@@ -1,5 +1,3 @@
-extern long sys_clone(unsigned long clone_flags, unsigned long newsp,
-               void __user *parent_tid, void __user *child_tid);
 #ifdef __i386__
 #include "syscalls_32.h"
 #else
diff --git a/arch/x86/um/sys_call_table_32.c b/arch/x86/um/sys_call_table_32.c
index 232e60504b3a..812e98c098e4 100644
--- a/arch/x86/um/sys_call_table_32.c
+++ b/arch/x86/um/sys_call_table_32.c
@@ -24,13 +24,10 @@
 #define old_mmap sys_old_mmap
-#define ptregs_fork sys_fork
 #define ptregs_iopl sys_iopl
 #define ptregs_vm86old sys_vm86old
-#define ptregs_clone i386_clone
 #define ptregs_vm86 sys_vm86
 #define ptregs_sigaltstack sys_sigaltstack
-#define ptregs_vfork sys_vfork
 #define __SYSCALL_I386(nr, sym, compat) extern asmlinkage void sym(void) ;
 #include <asm/syscalls_32.h>
diff --git a/arch/x86/um/syscalls_32.c b/arch/x86/um/syscalls_32.c
index db444c7218fe..e8bcea99acdb 100644
--- a/arch/x86/um/syscalls_32.c
+++ b/arch/x86/um/syscalls_32.c
@@ -6,21 +6,6 @@
 #include <linux/syscalls.h>
 #include <sysdep/syscalls.h>
-/*
- * The prototype on i386 is:
- *
- *     int clone(int flags, void * child_stack, int * parent_tidptr, struct user_desc * newtls
- *
- * and the "newtls" arg. on i386 is read by copy_thread directly from the
- * register saved on the stack.
- */
-long i386_clone(unsigned long clone_flags, unsigned long newsp,
-                int __user *parent_tid, void *newtls, int __user *child_tid)
-{
-        return sys_clone(clone_flags, newsp, parent_tid, child_tid);
-}
 long sys_sigaction(int sig, const struct old_sigaction __user *act,
                         struct old_sigaction __user *oact)
 {
diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index 0d1f36a22c98..2481f267be29 100644
--- a/arch/xtensa/Kconfig
+++ b/arch/xtensa/Kconfig
@@ -16,6 +16,7 @@ config XTENSA
        select GENERIC_KERNEL_THREAD
        select GENERIC_KERNEL_EXECVE
        select ARCH_WANT_OPTIONAL_GPIOLIB
+        select CLONE_BACKWARDS
        help
          Xtensa processors are 32-bit RISC machines designed by Tensilica
          primarily for embedded systems.  These processors are both
diff --git a/arch/xtensa/include/asm/signal.h b/arch/xtensa/include/asm/signal.h
index 72fd44c85b70..6f586bd90e18 100644
--- a/arch/xtensa/include/asm/signal.h
+++ b/arch/xtensa/include/asm/signal.h
@@ -27,7 +27,6 @@ struct k_sigaction {
 };
 #include <asm/sigcontext.h>
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif  /* __ASSEMBLY__ */
 #endif  /* _XTENSA_SIGNAL_H */
diff --git a/arch/xtensa/include/asm/syscall.h b/arch/xtensa/include/asm/syscall.h
index 124aeee0d381..b00c928d4cce 100644
--- a/arch/xtensa/include/asm/syscall.h
+++ b/arch/xtensa/include/asm/syscall.h
@@ -10,8 +10,6 @@
 struct pt_regs;
 struct sigaction;
-asmlinkage long sys_execve(char*, char**, char**, struct pt_regs*);
-asmlinkage long xtensa_clone(unsigned long, unsigned long, struct pt_regs*);
 asmlinkage long xtensa_ptrace(long, long, long, long);
 asmlinkage long xtensa_sigreturn(struct pt_regs*);
 asmlinkage long xtensa_rt_sigreturn(struct pt_regs*);
diff --git a/arch/xtensa/include/asm/unistd.h b/arch/xtensa/include/asm/unistd.h
index f4e6eaa40d1c..e002dbcc88b6 100644
--- a/arch/xtensa/include/asm/unistd.h
+++ b/arch/xtensa/include/asm/unistd.h
@@ -2,6 +2,7 @@
 #define _XTENSA_UNISTD_H
 #define __ARCH_WANT_SYS_EXECVE
+#define __ARCH_WANT_SYS_CLONE
 #include <uapi/asm/unistd.h>
 /*
diff --git a/arch/xtensa/include/uapi/asm/unistd.h b/arch/xtensa/include/uapi/asm/unistd.h
index 9f36d0e3e0ac..5162418c5d90 100644
--- a/arch/xtensa/include/uapi/asm/unistd.h
+++ b/arch/xtensa/include/uapi/asm/unistd.h
@@ -260,7 +260,7 @@ __SYSCALL(115, sys_sendmmsg, 4)
 /* Process Operations */
 #define __NR_clone                              116
-__SYSCALL(116, xtensa_clone, 5)
+__SYSCALL(116, sys_clone, 5)
 #define __NR_execve                             117
 __SYSCALL(117, sys_execve, 3)
 #define __NR_exit                               118
diff --git a/arch/xtensa/kernel/process.c b/arch/xtensa/kernel/process.c
index 09ae7bfab9a7..1accf28da5f5 100644
--- a/arch/xtensa/kernel/process.c
+++ b/arch/xtensa/kernel/process.c
@@ -199,8 +199,7 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 */
 int copy_thread(unsigned long clone_flags, unsigned long usp_thread_fn,
-                unsigned long thread_fn_arg,
+                unsigned long thread_fn_arg, struct task_struct *p)
-                struct task_struct *p, struct pt_regs *unused)
 {
        struct pt_regs *childregs = task_pt_regs(p);
@@ -364,12 +363,3 @@ int dump_fpu(void)
 {
        return 0;
 }
-asmlinkage
-long xtensa_clone(unsigned long clone_flags, unsigned long newsp,
-                  void __user *parent_tid, void *child_tls,
-                  void __user *child_tid, long a5,
-                  struct pt_regs *regs)
-{
-        return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
-}
diff --git a/drivers/staging/gdm72xx/gdm_usb.c b/drivers/staging/gdm72xx/gdm_usb.c
index bce6104bbab8..e0cb2ffb41be 100644
--- a/drivers/staging/gdm72xx/gdm_usb.c
+++ b/drivers/staging/gdm72xx/gdm_usb.c
@@ -739,8 +739,6 @@ static int k_mode_thread(void *arg)
        unsigned long flags, flags2, expire;
        int ret;
-        daemonize("k_mode_wimax");
        while (!k_mode_stop) {
                spin_lock_irqsave(&k_lock, flags2);
@@ -806,7 +804,7 @@ static struct usb_driver gdm_usb_driver = {
 static int __init usb_gdm_wimax_init(void)
 {
 #ifdef CONFIG_WIMAX_GDM72XX_K_MODE
-        kthread_run(k_mode_thread, NULL, "WiMax_thread");
+        kthread_run(k_mode_thread, NULL, "k_mode_wimax");
 #endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
        return usb_register(&gdm_usb_driver);
 }
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 0e7a6f81ae36..6043567b95c2 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -30,7 +30,7 @@
 #include <asm/cacheflush.h>
 #include <asm/a.out-core.h>
-static int load_aout_binary(struct linux_binprm *, struct pt_regs * regs);
+static int load_aout_binary(struct linux_binprm *);
 static int load_aout_library(struct file*);
 #ifdef CONFIG_COREDUMP
@@ -201,8 +201,9 @@ static unsigned long __user *create_aout_tables(char __user *p, struct linux_bin
 * libraries.  There is no binary dependent code anywhere else.
 */
-static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
+static int load_aout_binary(struct linux_binprm * bprm)
 {
+        struct pt_regs *regs = current_pt_regs();
        struct exec ex;
        unsigned long error;
        unsigned long fd_offset;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index fbd9f60bd763..6d7d1647a68c 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -44,7 +44,7 @@
 #define user_siginfo_t siginfo_t
 #endif
-static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
+static int load_elf_binary(struct linux_binprm *bprm);
 static int load_elf_library(struct file *);
 static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
                                int, int, unsigned long);
@@ -558,7 +558,7 @@ static unsigned long randomize_stack_top(unsigned long stack_top)
 #endif
 }
-static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+static int load_elf_binary(struct linux_binprm *bprm)
 {
        struct file *interpreter = NULL; /* to shut gcc up */
        unsigned long load_addr = 0, load_bias = 0;
@@ -575,6 +575,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
        unsigned long reloc_func_desc __maybe_unused = 0;
        int executable_stack = EXSTACK_DEFAULT;
        unsigned long def_flags = 0;
+        struct pt_regs *regs = current_pt_regs();
        struct {
                struct elfhdr elf_ex;
                struct elfhdr interp_elf_ex;
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index a46049154107..dc84732e554f 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -56,7 +56,7 @@ typedef char *elf_caddr_t;
 MODULE_LICENSE("GPL");
-static int load_elf_fdpic_binary(struct linux_binprm *, struct pt_regs *);
+static int load_elf_fdpic_binary(struct linux_binprm *);
 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *, struct file *);
 static int elf_fdpic_map_file(struct elf_fdpic_params *, struct file *,
                              struct mm_struct *, const char *);
@@ -164,10 +164,10 @@ static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *params,
 /*
 * load an fdpic binary into various bits of memory
 */
-static int load_elf_fdpic_binary(struct linux_binprm *bprm,
+static int load_elf_fdpic_binary(struct linux_binprm *bprm)
-                                 struct pt_regs *regs)
 {
        struct elf_fdpic_params exec_params, interp_params;
+        struct pt_regs *regs = current_pt_regs();
        struct elf_phdr *phdr;
        unsigned long stack_size, entryaddr;
 #ifdef ELF_FDPIC_PLAT_INIT
diff --git a/fs/binfmt_em86.c b/fs/binfmt_em86.c
index 2790c7e1912e..4e6cce57d113 100644
--- a/fs/binfmt_em86.c
+++ b/fs/binfmt_em86.c
@@ -22,7 +22,7 @@
 #define EM86_INTERP     "/usr/bin/em86"
 #define EM86_I_NAME     "em86"
-static int load_em86(struct linux_binprm *bprm,struct pt_regs *regs)
+static int load_em86(struct linux_binprm *bprm)
 {
        char *interp, *i_name, *i_arg;
        struct file * file;
@@ -90,7 +90,7 @@ static int load_em86(struct linux_binprm *bprm,struct pt_regs *regs)
        if (retval < 0)
                return retval;
-        return search_binary_handler(bprm, regs);
+        return search_binary_handler(bprm);
 }
 static struct linux_binfmt em86_format = {
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index e280352b28f9..b56371981d16 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -88,7 +88,7 @@ struct lib_info {
 static int load_flat_shared_library(int id, struct lib_info *p);
 #endif
-static int load_flat_binary(struct linux_binprm *, struct pt_regs * regs);
+static int load_flat_binary(struct linux_binprm *);
 static int flat_core_dump(struct coredump_params *cprm);
 static struct linux_binfmt flat_format = {
@@ -858,9 +858,10 @@ out:
 * libraries.  There is no binary dependent code anywhere else.
 */
-static int load_flat_binary(struct linux_binprm * bprm, struct pt_regs * regs)
+static int load_flat_binary(struct linux_binprm * bprm)
 {
        struct lib_info libinfo;
+        struct pt_regs *regs = current_pt_regs();
        unsigned long p = bprm->p;
        unsigned long stack_len;
        unsigned long start_addr;
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 790b3cddca67..b0b70fbea06c 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -104,7 +104,7 @@ static Node *check_file(struct linux_binprm *bprm)
 /*
 * the loader itself
 */
-static int load_misc_binary(struct linux_binprm *bprm, struct pt_regs *regs)
+static int load_misc_binary(struct linux_binprm *bprm)
 {
        Node *fmt;
        struct file * interp_file = NULL;
@@ -199,7 +199,7 @@ static int load_misc_binary(struct linux_binprm *bprm, struct pt_regs *regs)
        bprm->recursion_depth++;
-        retval = search_binary_handler (bprm, regs);
+        retval = search_binary_handler(bprm);
        if (retval < 0)
                goto _error;
diff --git a/fs/binfmt_script.c b/fs/binfmt_script.c
index d3b8c1f63155..8c954997e7f7 100644
--- a/fs/binfmt_script.c
+++ b/fs/binfmt_script.c
@@ -14,7 +14,7 @@
 #include <linux/err.h>
 #include <linux/fs.h>
-static int load_script(struct linux_binprm *bprm,struct pt_regs *regs)
+static int load_script(struct linux_binprm *bprm)
 {
        const char *i_arg, *i_name;
        char *cp;
@@ -95,7 +95,7 @@ static int load_script(struct linux_binprm *bprm,struct pt_regs *regs)
        retval = prepare_binprm(bprm);
        if (retval < 0)
                return retval;
-        return search_binary_handler(bprm,regs);
+        return search_binary_handler(bprm);
 }
 static struct linux_binfmt script_format = {
diff --git a/fs/binfmt_som.c b/fs/binfmt_som.c
index 4517aaff61b4..4e00ed68d4a6 100644
--- a/fs/binfmt_som.c
+++ b/fs/binfmt_som.c
@@ -35,7 +35,7 @@
 #include <linux/elf.h>
-static int load_som_binary(struct linux_binprm * bprm, struct pt_regs * regs);
+static int load_som_binary(struct linux_binprm * bprm);
 static int load_som_library(struct file *);
 /*
@@ -180,13 +180,14 @@ out:
 */
 static int
-load_som_binary(struct linux_binprm * bprm, struct pt_regs * regs)
+load_som_binary(struct linux_binprm * bprm)
 {
        int retval;
        unsigned int size;
        unsigned long som_entry;
        struct som_hdr *som_ex;
        struct som_exec_auxhdr *hpuxhdr;
+        struct pt_regs *regs = current_pt_regs();
        /* Get the exec-header */
        som_ex = (struct som_hdr *) bprm->buf;
diff --git a/fs/coredump.c b/fs/coredump.c
index ce47379bfa61..177493272a61 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -458,7 +458,7 @@ static int umh_pipe_setup(struct subprocess_info *info, struct cred *new)
        return err;
 }
-void do_coredump(siginfo_t *siginfo, struct pt_regs *regs)
+void do_coredump(siginfo_t *siginfo)
 {
        struct core_state core_state;
        struct core_name cn;
@@ -474,7 +474,7 @@ void do_coredump(siginfo_t *siginfo, struct pt_regs *regs)
        static atomic_t core_dump_count = ATOMIC_INIT(0);
        struct coredump_params cprm = {
                .siginfo = siginfo,
-                .regs = regs,
+                .regs = signal_pt_regs(),
                .limit = rlimit(RLIMIT_CORE),
                /*
                 * We must use the same mm->flags while dumping core to avoid
diff --git a/fs/exec.c b/fs/exec.c
index 0039055b1fc6..721a29929511 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1349,7 +1349,7 @@ EXPORT_SYMBOL(remove_arg_zero);
 /*
 * cycle the list of binary formats handler, until one recognizes the image
 */
-int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
+int search_binary_handler(struct linux_binprm *bprm)
 {
        unsigned int depth = bprm->recursion_depth;
        int try,retval;
@@ -1374,13 +1374,13 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
        for (try=0; try<2; try++) {
                read_lock(&binfmt_lock);
                list_for_each_entry(fmt, &formats, lh) {
-                        int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
+                        int (*fn)(struct linux_binprm *) = fmt->load_binary;
                        if (!fn)
                                continue;
                        if (!try_module_get(fmt->module))
                                continue;
                        read_unlock(&binfmt_lock);
-                        retval = fn(bprm, regs);
+                        retval = fn(bprm);
                        /*
                         * Restore the depth counter to its starting value
                         * in this call, so we don't have to rely on every
@@ -1439,8 +1439,7 @@ EXPORT_SYMBOL(search_binary_handler);
 */
 static int do_execve_common(const char *filename,
                                struct user_arg_ptr argv,
-                                struct user_arg_ptr envp,
+                                struct user_arg_ptr envp)
-                                struct pt_regs *regs)
 {
        struct linux_binprm *bprm;
        struct file *file;
@@ -1524,7 +1523,7 @@ static int do_execve_common(const char *filename,
        if (retval < 0)
                goto out;
-        retval = search_binary_handler(bprm,regs);
+        retval = search_binary_handler(bprm);
        if (retval < 0)
                goto out;
@@ -1566,19 +1565,17 @@ out_ret:
 int do_execve(const char *filename,
        const char __user *const __user *__argv,
-        const char __user *const __user *__envp,
+        const char __user *const __user *__envp)
-        struct pt_regs *regs)
 {
        struct user_arg_ptr argv = { .ptr.native = __argv };
        struct user_arg_ptr envp = { .ptr.native = __envp };
-        return do_execve_common(filename, argv, envp, regs);
+        return do_execve_common(filename, argv, envp);
 }
 #ifdef CONFIG_COMPAT
-int compat_do_execve(const char *filename,
+static int compat_do_execve(const char *filename,
        const compat_uptr_t __user *__argv,
-        const compat_uptr_t __user *__envp,
+        const compat_uptr_t __user *__envp)
-        struct pt_regs *regs)
 {
        struct user_arg_ptr argv = {
                .is_compat = true,
@@ -1588,7 +1585,7 @@ int compat_do_execve(const char *filename,
                .is_compat = true,
                .ptr.compat = __envp,
        };
-        return do_execve_common(filename, argv, envp, regs);
+        return do_execve_common(filename, argv, envp);
 }
 #endif
@@ -1669,7 +1666,7 @@ SYSCALL_DEFINE3(execve,
        struct filename *path = getname(filename);
        int error = PTR_ERR(path);
        if (!IS_ERR(path)) {
-                error = do_execve(path->name, argv, envp, current_pt_regs());
+                error = do_execve(path->name, argv, envp);
                putname(path);
        }
        return error;
@@ -1682,8 +1679,7 @@ asmlinkage long compat_sys_execve(const char __user * filename,
        struct filename *path = getname(filename);
        int error = PTR_ERR(path);
        if (!IS_ERR(path)) {
-                error = compat_do_execve(path->name, argv, envp,
+                error = compat_do_execve(path->name, argv, envp);
-                                                        current_pt_regs());
                putname(path);
        }
        return error;
@@ -1696,12 +1692,9 @@ int kernel_execve(const char *filename,
                  const char *const argv[],
                  const char *const envp[])
 {
-        struct pt_regs *p = current_pt_regs();
+        int ret = do_execve(filename,
-        int ret;
-        ret = do_execve(filename,
                        (const char __user *const __user *)argv,
-                        (const char __user *const __user *)envp, p);
+                        (const char __user *const __user *)envp);
        if (ret < 0)
                return ret;
@@ -1709,6 +1702,6 @@ int kernel_execve(const char *filename,
         * We were successful.  We won't be returning to our caller, but
         * instead to user space by manipulating the kernel stack.
         */
-        ret_from_kernel_execve(p);
+        ret_from_kernel_execve(current_pt_regs());
 }
 #endif
diff --git a/fs/file.c b/fs/file.c
index eff23162485f..15cb8618e95d 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -519,12 +519,6 @@ struct files_struct init_files = {
        .file_lock      = __SPIN_LOCK_UNLOCKED(init_task.file_lock),
 };
-void daemonize_descriptors(void)
-{
-        atomic_inc(&init_files.count);
-        reset_files_struct(&init_files);
-}
 /*
 * allocate a file descriptor, mark it busy.
 */
diff --git a/fs/fs_struct.c b/fs/fs_struct.c
index 5df4775fea03..fe6ca583bbc0 100644
--- a/fs/fs_struct.c
+++ b/fs/fs_struct.c
@@ -164,27 +164,3 @@ struct fs_struct init_fs = {
        .seq            = SEQCNT_ZERO,
        .umask          = 0022,
 };
-void daemonize_fs_struct(void)
-{
-        struct fs_struct *fs = current->fs;
-        if (fs) {
-                int kill;
-                task_lock(current);
-                spin_lock(&init_fs.lock);
-                init_fs.users++;
-                spin_unlock(&init_fs.lock);
-                spin_lock(&fs->lock);
-                current->fs = &init_fs;
-                kill = !--fs->users;
-                spin_unlock(&fs->lock);
-                task_unlock(current);
-                if (kill)
-                        free_fs_struct(fs);
-        }
-}
diff --git a/include/asm-generic/signal.h b/include/asm-generic/signal.h
index 98caa306122a..d840c90a157a 100644
--- a/include/asm-generic/signal.h
+++ b/include/asm-generic/signal.h
@@ -10,7 +10,5 @@
 #include <asm/sigcontext.h>
 #undef __HAVE_ARCH_SIG_BITOPS
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
 #endif /* __ASSEMBLY__ */
 #endif /* _ASM_GENERIC_SIGNAL_H */
diff --git a/include/asm-generic/syscalls.h b/include/asm-generic/syscalls.h
index d89dec864d42..58f466ff00d3 100644
--- a/include/asm-generic/syscalls.h
+++ b/include/asm-generic/syscalls.h
@@ -8,26 +8,6 @@
 * Calling conventions for these system calls can differ, so
 * it's possible to override them.
 */
-#ifndef sys_clone
-asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
-                        void __user *parent_tid, void __user *child_tid,
-                        struct pt_regs *regs);
-#endif
-#ifndef sys_fork
-asmlinkage long sys_fork(struct pt_regs *regs);
-#endif
-#ifndef sys_vfork
-asmlinkage long sys_vfork(struct pt_regs *regs);
-#endif
-#ifndef sys_execve
-asmlinkage long sys_execve(const char __user *filename,
-                           const char __user *const __user *argv,
-                           const char __user *const __user *envp,
-                           struct pt_regs *regs);
-#endif
 #ifndef sys_mmap2
 asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index cfcc6bfcaec0..2630c9b41a86 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -72,7 +72,7 @@ struct coredump_params {
 struct linux_binfmt {
        struct list_head lh;
        struct module *module;
-        int (*load_binary)(struct linux_binprm *, struct  pt_regs * regs);
+        int (*load_binary)(struct linux_binprm *);
        int (*load_shlib)(struct file *);
        int (*core_dump)(struct coredump_params *cprm);
        unsigned long min_coredump;     /* minimal dump size */
@@ -95,7 +95,7 @@ extern void unregister_binfmt(struct linux_binfmt *);
 extern int prepare_binprm(struct linux_binprm *);
 extern int __must_check remove_arg_zero(struct linux_binprm *);
-extern int search_binary_handler(struct linux_binprm *, struct pt_regs *);
+extern int search_binary_handler(struct linux_binprm *);
 extern int flush_old_exec(struct linux_binprm * bprm);
 extern void setup_new_exec(struct linux_binprm * bprm);
 extern void would_dump(struct linux_binprm *, struct file *);
diff --git a/include/linux/compat.h b/include/linux/compat.h
index d0ced1011f2f..784ebfe63c48 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -284,12 +284,8 @@ asmlinkage ssize_t compat_sys_pwritev(unsigned long fd,
                const struct compat_iovec __user *vec,
                unsigned long vlen, u32 pos_low, u32 pos_high);
-int compat_do_execve(const char *filename, const compat_uptr_t __user *argv,
-                     const compat_uptr_t __user *envp, struct pt_regs *regs);
-#ifdef __ARCH_WANT_SYS_EXECVE
 asmlinkage long compat_sys_execve(const char __user *filename, const compat_uptr_t __user *argv,
                     const compat_uptr_t __user *envp);
-#endif
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
                compat_ulong_t __user *outp, compat_ulong_t __user *exp,
diff --git a/include/linux/coredump.h b/include/linux/coredump.h
index 1d7399314a89..a98f1ca60407 100644
--- a/include/linux/coredump.h
+++ b/include/linux/coredump.h
@@ -13,9 +13,9 @@
 extern int dump_write(struct file *file, const void *addr, int nr);
 extern int dump_seek(struct file *file, loff_t off);
 #ifdef CONFIG_COREDUMP
-extern void do_coredump(siginfo_t *siginfo, struct pt_regs *regs);
+extern void do_coredump(siginfo_t *siginfo);
 #else
-static inline void do_coredump(siginfo_t *siginfo, struct pt_regs *regs) {}
+static inline void do_coredump(siginfo_t *siginfo) {}
 #endif
 #endif /* _LINUX_COREDUMP_H */
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 45052aa814c8..fb7dacae0522 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -95,7 +95,6 @@ struct task_struct;
 struct files_struct *get_files_struct(struct task_struct *);
 void put_files_struct(struct files_struct *fs);
 void reset_files_struct(struct files_struct *);
-void daemonize_descriptors(void);
 int unshare_files(struct files_struct **);
 struct files_struct *dup_fd(struct files_struct *, int *);
 void do_close_on_exec(struct files_struct *);
diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
index 003dc0fd7347..d0ae3a84bcfb 100644
--- a/include/linux/fs_struct.h
+++ b/include/linux/fs_struct.h
@@ -21,7 +21,6 @@ extern void set_fs_root(struct fs_struct *, struct path *);
 extern void set_fs_pwd(struct fs_struct *, struct path *);
 extern struct fs_struct *copy_fs_struct(struct fs_struct *);
 extern void free_fs_struct(struct fs_struct *);
-extern void daemonize_fs_struct(void);
 extern int unshare_fs_struct(void);
 static inline void get_fs_root(struct fs_struct *fs, struct path *root)
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index e0ff4689d35a..a89ff04bddd9 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -329,6 +329,19 @@ static inline void user_single_step_siginfo(struct task_struct *tsk,
 #define current_pt_regs() task_pt_regs(current)
 #endif
+#ifndef ptrace_signal_deliver
+#define ptrace_signal_deliver() ((void)0)
+#endif
+/*
+ * unlike current_pt_regs(), this one is equal to task_pt_regs(current)
+ * on *all* architectures; the only reason to have a per-arch definition
+ * is optimisation.
+ */
+#ifndef signal_pt_regs
+#define signal_pt_regs() task_pt_regs(current)
+#endif
 extern int task_current_syscall(struct task_struct *target, long *callno,
                                unsigned long args[6], unsigned int maxargs,
                                unsigned long *sp, unsigned long *pc);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b96ff1e43ada..651b51a36711 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2303,7 +2303,7 @@ extern void mm_release(struct task_struct *, struct mm_struct *);
 extern struct mm_struct *dup_mm(struct task_struct *tsk);
 extern int copy_thread(unsigned long, unsigned long, unsigned long,
-                        struct task_struct *, struct pt_regs *);
+                        struct task_struct *);
 extern void flush_thread(void);
 extern void exit_thread(void);
@@ -2315,14 +2315,13 @@ extern void flush_itimer_signals(void);
 extern void do_group_exit(int);
-extern void daemonize(const char *, ...);
 extern int allow_signal(int);
 extern int disallow_signal(int);
 extern int do_execve(const char *,
                     const char __user * const __user *,
-                     const char __user * const __user *, struct pt_regs *);
+                     const char __user * const __user *);
-extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
+extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
 struct task_struct *fork_idle(int);
 #ifdef CONFIG_GENERIC_KERNEL_THREAD
 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 727f0cd73921..91835e7f364d 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -833,10 +833,22 @@ int kernel_execve(const char *filename, const char *const argv[], const char *co
 #define kernel_execve(filename, argv, envp) \
        do_execve(filename, \
                (const char __user *const __user *)argv, \
-                (const char __user *const __user *)envp, \
+                (const char __user *const __user *)envp)
-                current_pt_regs())
 #endif
+asmlinkage long sys_fork(void);
+asmlinkage long sys_vfork(void);
+#ifdef CONFIG_CLONE_BACKWARDS
+asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, int,
+               int __user *);
+#else
+asmlinkage long sys_clone(unsigned long, unsigned long, int __user *,
+               int __user *, int);
+#endif
+asmlinkage long sys_execve(const char __user *filename,
+                const char __user *const __user *argv,
+                const char __user *const __user *envp);
 asmlinkage long sys_perf_event_open(
                struct perf_event_attr __user *attr_uptr,
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index fc7376bf86ea..e37e6a12c5e3 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -200,7 +200,6 @@ struct audit_context {
        struct list_head    names_list; /* anchor for struct audit_names->list */
        char *              filterkey;  /* key for rule that triggered record */
        struct path         pwd;
-        struct audit_context *previous; /* For nested syscalls */
        struct audit_aux_data *aux;
        struct audit_aux_data *aux_pids;
        struct sockaddr_storage *sockaddr;
@@ -1091,29 +1090,13 @@ int audit_alloc(struct task_struct *tsk)
 static inline void audit_free_context(struct audit_context *context)
 {
-        struct audit_context *previous;
+        audit_free_names(context);
-        int                  count = 0;
+        unroll_tree_refs(context, NULL, 0);
+        free_tree_refs(context);
-        do {
+        audit_free_aux(context);
-                previous = context->previous;
+        kfree(context->filterkey);
-                if (previous || (count &&  count < 10)) {
+        kfree(context->sockaddr);
-                        ++count;
+        kfree(context);
-                        printk(KERN_ERR "audit(:%d): major=%d name_count=%d:"
-                               " freeing multiple contexts (%d)\n",
-                               context->serial, context->major,
-                               context->name_count, count);
-                }
-                audit_free_names(context);
-                unroll_tree_refs(context, NULL, 0);
-                free_tree_refs(context);
-                audit_free_aux(context);
-                kfree(context->filterkey);
-                kfree(context->sockaddr);
-                kfree(context);
-                context  = previous;
-        } while (context);
-        if (count >= 10)
-                printk(KERN_ERR "audit: freed %d contexts\n", count);
 }
 void audit_log_task_context(struct audit_buffer *ab)
@@ -1783,42 +1766,6 @@ void __audit_syscall_entry(int arch, int major,
        if (!context)
                return;
-        /*
-         * This happens only on certain architectures that make system
-         * calls in kernel_thread via the entry.S interface, instead of
-         * with direct calls.  (If you are porting to a new
-         * architecture, hitting this condition can indicate that you
-         * got the _exit/_leave calls backward in entry.S.)
-         *
-         * i386     no
-         * x86_64   no
-         * ppc64    yes (see arch/powerpc/platforms/iseries/misc.S)
-         *
-         * This also happens with vm86 emulation in a non-nested manner
-         * (entries without exits), so this case must be caught.
-         */
-        if (context->in_syscall) {
-                struct audit_context *newctx;
-#if AUDIT_DEBUG
-                printk(KERN_ERR
-                       "audit(:%d) pid=%d in syscall=%d;"
-                       " entering syscall=%d\n",
-                       context->serial, tsk->pid, context->major, major);
-#endif
-                newctx = audit_alloc_context(context->state);
-                if (newctx) {
-                        newctx->previous   = context;
-                        context            = newctx;
-                        tsk->audit_context = newctx;
-                } else  {
-                        /* If we can't alloc a new context, the best we
-                         * can do is to leak memory (any pending putname
-                         * will be lost).  The only other alternative is
-                         * to abandon auditing. */
-                        audit_zero_context(context, context->state);
-                }
-        }
        BUG_ON(context->in_syscall || context->name_count);
        if (!audit_enabled)
@@ -1881,28 +1828,21 @@ void __audit_syscall_exit(int success, long return_code)
        if (!list_empty(&context->killed_trees))
                audit_kill_trees(&context->killed_trees);
-        if (context->previous) {
+        audit_free_names(context);
-                struct audit_context *new_context = context->previous;
+        unroll_tree_refs(context, NULL, 0);
-                context->previous  = NULL;
+        audit_free_aux(context);
-                audit_free_context(context);
+        context->aux = NULL;
-                tsk->audit_context = new_context;
+        context->aux_pids = NULL;
-        } else {
+        context->target_pid = 0;
-                audit_free_names(context);
+        context->target_sid = 0;
-                unroll_tree_refs(context, NULL, 0);
+        context->sockaddr_len = 0;
-                audit_free_aux(context);
+        context->type = 0;
-                context->aux = NULL;
+        context->fds[0] = -1;
-                context->aux_pids = NULL;
+        if (context->state != AUDIT_RECORD_CONTEXT) {
-                context->target_pid = 0;
+                kfree(context->filterkey);
-                context->target_sid = 0;
+                context->filterkey = NULL;
-                context->sockaddr_len = 0;
-                context->type = 0;
-                context->fds[0] = -1;
-                if (context->state != AUDIT_RECORD_CONTEXT) {
-                        kfree(context->filterkey);
-                        context->filterkey = NULL;
-                }
-                tsk->audit_context = context;
        }
+        tsk->audit_context = context;
 }
 static inline void handle_one(const struct inode *inode)
diff --git a/kernel/exit.c b/kernel/exit.c
index 618f7ee56003..50d2e93c36ea 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -322,43 +322,6 @@ kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
        }
 }
-/**
- * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd
- *
- * If a kernel thread is launched as a result of a system call, or if
- * it ever exits, it should generally reparent itself to kthreadd so it
- * isn't in the way of other processes and is correctly cleaned up on exit.
- *
- * The various task state such as scheduling policy and priority may have
- * been inherited from a user process, so we reset them to sane values here.
- *
- * NOTE that reparent_to_kthreadd() gives the caller full capabilities.
- */
-static void reparent_to_kthreadd(void)
-{
-        write_lock_irq(&tasklist_lock);
-        ptrace_unlink(current);
-        /* Reparent to init */
-        current->real_parent = current->parent = kthreadd_task;
-        list_move_tail(&current->sibling, &current->real_parent->children);
-        /* Set the exit signal to SIGCHLD so we signal init on exit */
-        current->exit_signal = SIGCHLD;
-        if (task_nice(current) < 0)
-                set_user_nice(current, 0);
-        /* cpus_allowed? */
-        /* rt_priority? */
-        /* signals? */
-        memcpy(current->signal->rlim, init_task.signal->rlim,
-               sizeof(current->signal->rlim));
-        atomic_inc(&init_cred.usage);
-        commit_creds(&init_cred);
-        write_unlock_irq(&tasklist_lock);
-}
 void __set_special_pids(struct pid *pid)
 {
        struct task_struct *curr = current->group_leader;
@@ -370,13 +333,6 @@ void __set_special_pids(struct pid *pid)
                change_pid(curr, PIDTYPE_PGID, pid);
 }
-static void set_special_pids(struct pid *pid)
-{
-        write_lock_irq(&tasklist_lock);
-        __set_special_pids(pid);
-        write_unlock_irq(&tasklist_lock);
-}
 /*
 * Let kernel threads use this to say that they allow a certain signal.
 * Must not be used if kthread was cloned with CLONE_SIGHAND.
@@ -416,54 +372,6 @@ int disallow_signal(int sig)
 EXPORT_SYMBOL(disallow_signal);
-/*
- *      Put all the gunge required to become a kernel thread without
- *      attached user resources in one place where it belongs.
- */
-void daemonize(const char *name, ...)
-{
-        va_list args;
-        sigset_t blocked;
-        va_start(args, name);
-        vsnprintf(current->comm, sizeof(current->comm), name, args);
-        va_end(args);
-        /*
-         * If we were started as result of loading a module, close all of the
-         * user space pages.  We don't need them, and if we didn't close them
-         * they would be locked into memory.
-         */
-        exit_mm(current);
-        /*
-         * We don't want to get frozen, in case system-wide hibernation
-         * or suspend transition begins right now.
-         */
-        current->flags |= (PF_NOFREEZE | PF_KTHREAD);
-        if (current->nsproxy != &init_nsproxy) {
-                get_nsproxy(&init_nsproxy);
-                switch_task_namespaces(current, &init_nsproxy);
-        }
-        set_special_pids(&init_struct_pid);
-        proc_clear_tty(current);
-        /* Block and flush all signals */
-        sigfillset(&blocked);
-        sigprocmask(SIG_BLOCK, &blocked, NULL);
-        flush_signals(current);
-        /* Become as one with the init task */
-        daemonize_fs_struct();
-        daemonize_descriptors();
-        reparent_to_kthreadd();
-}
-EXPORT_SYMBOL(daemonize);
 #ifdef CONFIG_MM_OWNER
 /*
 * A task is exiting.   If it owned this mm, find a new owner for the mm.
diff --git a/kernel/fork.c b/kernel/fork.c
index 79de9f99a48d..3c31e874afad 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1129,7 +1129,6 @@ static void posix_cpu_timers_init(struct task_struct *tsk)
 */
 static struct task_struct *copy_process(unsigned long clone_flags,
                                        unsigned long stack_start,
-                                        struct pt_regs *regs,
                                        unsigned long stack_size,
                                        int __user *child_tidptr,
                                        struct pid *pid,
@@ -1321,7 +1320,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
        retval = copy_io(clone_flags, p);
        if (retval)
                goto bad_fork_cleanup_namespaces;
-        retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
+        retval = copy_thread(clone_flags, stack_start, stack_size, p);
        if (retval)
                goto bad_fork_cleanup_io;
@@ -1510,12 +1509,6 @@ fork_out:
        return ERR_PTR(retval);
 }
-noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
-{
-        memset(regs, 0, sizeof(struct pt_regs));
-        return regs;
-}
 static inline void init_idle_pids(struct pid_link *links)
 {
        enum pid_type type;
@@ -1529,10 +1522,7 @@ static inline void init_idle_pids(struct pid_link *links)
 struct task_struct * __cpuinit fork_idle(int cpu)
 {
        struct task_struct *task;
-        struct pt_regs regs;
+        task = copy_process(CLONE_VM, 0, 0, NULL, &init_struct_pid, 0);
-        task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,
-                            &init_struct_pid, 0);
        if (!IS_ERR(task)) {
                init_idle_pids(task->pids);
                init_idle(task, cpu);
@@ -1549,7 +1539,6 @@ struct task_struct * __cpuinit fork_idle(int cpu)
 */
 long do_fork(unsigned long clone_flags,
              unsigned long stack_start,
-              struct pt_regs *regs,
              unsigned long stack_size,
              int __user *parent_tidptr,
              int __user *child_tidptr)
@@ -1579,7 +1568,7 @@ long do_fork(unsigned long clone_flags,
         * requested, no event is reported; otherwise, report if the event
         * for the type of forking is enabled.
         */
-        if (!(clone_flags & CLONE_UNTRACED) && likely(user_mode(regs))) {
+        if (!(clone_flags & CLONE_UNTRACED)) {
                if (clone_flags & CLONE_VFORK)
                        trace = PTRACE_EVENT_VFORK;
                else if ((clone_flags & CSIGNAL) != SIGCHLD)
@@ -1591,7 +1580,7 @@ long do_fork(unsigned long clone_flags,
                        trace = 0;
        }
-        p = copy_process(clone_flags, stack_start, regs, stack_size,
+        p = copy_process(clone_flags, stack_start, stack_size,
                         child_tidptr, NULL, trace);
        /*
         * Do this prior waking up the new thread - the thread pointer
@@ -1635,11 +1624,54 @@ long do_fork(unsigned long clone_flags,
 */
 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
-        return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn, NULL,
+        return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
                (unsigned long)arg, NULL, NULL);
 }
 #endif
+#ifdef __ARCH_WANT_SYS_FORK
+SYSCALL_DEFINE0(fork)
+{
+#ifdef CONFIG_MMU
+        return do_fork(SIGCHLD, 0, 0, NULL, NULL);
+#else
+        /* can not support in nommu mode */
+        return(-EINVAL);
+#endif
+}
+#endif
+#ifdef __ARCH_WANT_SYS_VFORK
+SYSCALL_DEFINE0(vfork)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 
+                        0, NULL, NULL);
+}
+#endif
+#ifdef __ARCH_WANT_SYS_CLONE
+#ifdef CONFIG_CLONE_BACKWARDS
+SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
+                 int __user *, parent_tidptr,
+                 int, tls_val,
+                 int __user *, child_tidptr)
+#elif defined(CONFIG_CLONE_BACKWARDS2)
+SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
+                 int __user *, parent_tidptr,
+                 int __user *, child_tidptr,
+                 int, tls_val)
+#else
+SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
+                 int __user *, parent_tidptr,
+                 int __user *, child_tidptr,
+                 int, tls_val)
+#endif
+{
+        return do_fork(clone_flags, newsp, 0,
+                parent_tidptr, child_tidptr);
+}
+#endif
 #ifndef ARCH_MIN_MMSTRUCT_ALIGN
 #define ARCH_MIN_MMSTRUCT_ALIGN 0
 #endif
diff --git a/kernel/signal.c b/kernel/signal.c
index 5ffb5626e072..a49c7f36ceb3 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1159,8 +1159,9 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
        return __send_signal(sig, info, t, group, from_ancestor_ns);
 }
-static void print_fatal_signal(struct pt_regs *regs, int signr)
+static void print_fatal_signal(int signr)
 {
+        struct pt_regs *regs = signal_pt_regs();
        printk("%s/%d: potentially unexpected fatal signal %d.\n",
                current->comm, task_pid_nr(current), signr);
@@ -2131,10 +2132,9 @@ static void do_jobctl_trap(void)
        }
 }
-static int ptrace_signal(int signr, siginfo_t *info,
+static int ptrace_signal(int signr, siginfo_t *info)
-                         struct pt_regs *regs, void *cookie)
 {
-        ptrace_signal_deliver(regs, cookie);
+        ptrace_signal_deliver();
        /*
         * We do not check sig_kernel_stop(signr) but set this marker
         * unconditionally because we do not know whether debugger will
@@ -2257,8 +2257,7 @@ relock:
                        break; /* will return 0 */
                if (unlikely(current->ptrace) && signr != SIGKILL) {
-                        signr = ptrace_signal(signr, info,
+                        signr = ptrace_signal(signr, info);
-                                              regs, cookie);
                        if (!signr)
                                continue;
                }
@@ -2343,7 +2342,7 @@ relock:
                if (sig_kernel_coredump(signr)) {
                        if (print_fatal_signals)
-                                print_fatal_signal(regs, info->si_signo);
+                                print_fatal_signal(info->si_signo);
                        /*
                         * If it was able to dump core, this kills all
                         * other threads in the group and synchronizes with
@@ -2352,7 +2351,7 @@ relock:
                         * first and our do_group_exit call below will use
                         * that value and ignore the one we pass it.
                         */
-                        do_coredump(info, regs);
+                        do_coredump(info);
                }
                /*