Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal

Pull generic execve() changes from Al Viro:
 "This introduces the generic kernel_thread() and kernel_execve()
  functions, and switches x86, arm, alpha, um and s390 over to them."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal: (26 commits)
  s390: convert to generic kernel_execve()
  s390: switch to generic kernel_thread()
  s390: fold kernel_thread_helper() into ret_from_fork()
  s390: fold execve_tail() into start_thread(), convert to generic sys_execve()
  um: switch to generic kernel_thread()
  x86, um/x86: switch to generic sys_execve and kernel_execve
  x86: split ret_from_fork
  alpha: introduce ret_from_kernel_execve(), switch to generic kernel_execve()
  alpha: switch to generic kernel_thread()
  alpha: switch to generic sys_execve()
  arm: get rid of execve wrapper, switch to generic execve() implementation
  arm: optimized current_pt_regs()
  arm: introduce ret_from_kernel_execve(), switch to generic kernel_execve()
  arm: split ret_from_fork, simplify kernel_thread() [based on patch by rmk]
  generic sys_execve()
  generic kernel_execve()
  new helper: current_pt_regs()
  preparation for generic kernel_thread()
  um: kill thread->forking
  um: let signal_delivered() do SIGTRAP on singlestepping into handler
  ...

3 files changed, 38 insertions, 113 deletions

diff --git a/arch/alpha/kernel/alpha_ksyms.c b/arch/alpha/kernel/alpha_ksyms.c
index 15fa821d09cd..89566b346c0f 100644
--- a/arch/alpha/kernel/alpha_ksyms.c
+++ b/arch/alpha/kernel/alpha_ksyms.c
@@ -50,9 +50,6 @@ EXPORT_SYMBOL(alpha_read_fp_reg_s);
 EXPORT_SYMBOL(alpha_write_fp_reg);
 EXPORT_SYMBOL(alpha_write_fp_reg_s);
 
-/* entry.S */
-EXPORT_SYMBOL(kernel_thread);
-
 /* Networking helper routines. */
 EXPORT_SYMBOL(csum_tcpudp_magic);
 EXPORT_SYMBOL(ip_compute_csum);
diff --git a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S
index ec0da0567ab5..7e43e1156d10 100644
--- a/arch/alpha/kernel/entry.S
+++ b/arch/alpha/kernel/entry.S
@@ -609,59 +609,35 @@ ret_from_fork:
 .end ret_from_fork
 
 /*
- * kernel_thread(fn, arg, clone_flags)
+ * ... and new kernel threads - here
  */
         .align 4
-        .globl  kernel_thread
-        .ent    kernel_thread
-kernel_thread:
-        /* We can be called from a module.  */
-        ldgp    $gp, 0($27)
-        .prologue 1
-        subq    $sp, SP_OFF+6*8, $sp
-        br      $1, 2f          /* load start address */
-
-        /* We've now "returned" from a fake system call.  */
-        unop
-        blt     $0, 1f          /* error?  */
-        ldi     $1, 0x3fff
-        beq     $20, 1f         /* parent or child?  */
-
-        bic     $sp, $1, $8     /* in child.  */
-        jsr     $26, ($27)
+        .globl  ret_from_kernel_thread
+        .ent    ret_from_kernel_thread
+ret_from_kernel_thread:
+        mov     $17, $16
+        jsr     $26, schedule_tail
+        mov     $9, $27
+        mov     $10, $16
+        jsr     $26, ($9)
         ldgp    $gp, 0($26)
         mov     $0, $16
         mov     $31, $26
         jmp     $31, sys_exit
+.end ret_from_kernel_thread
 
-1:      ret                     /* in parent.  */
-
-        .align 4
-2:      /* Fake a system call stack frame, as we can't do system calls
-           from kernel space.  Note that we store FN and ARG as they
-           need to be set up in the child for the call.  Also store $8
-           and $26 for use in the parent.  */
-        stq     $31, SP_OFF($sp)        /* ps */
-        stq     $1, SP_OFF+8($sp)       /* pc */
-        stq     $gp, SP_OFF+16($sp)     /* gp */
-        stq     $16, 136($sp)           /* $27; FN for child */
-        stq     $17, SP_OFF+24($sp)     /* $16; ARG for child */
-        stq     $8, 64($sp)             /* $8 */
-        stq     $26, 128($sp)           /* $26 */
+        .globl  ret_from_kernel_execve
+        .align  4
+        .ent    ret_from_kernel_execve
+ret_from_kernel_execve:
+        mov     $16, $sp
         /* Avoid the HAE being gratuitously wrong, to avoid restoring it.  */
         ldq     $2, alpha_mv+HAE_CACHE
         stq     $2, 152($sp)            /* HAE */
+        mov     $31, $19                /* to disable syscall restarts */
+        br      $31, ret_to_user
 
-        /* Shuffle FLAGS to the front; add CLONE_VM.  */
-        ldi     $1, CLONE_VM|CLONE_UNTRACED
-        or      $18, $1, $16
-        bsr     $26, sys_clone
-
-        /* We don't actually care for a3 success widgetry in the kernel.
-           Not for positive errno values.  */
-        stq     $0, 0($sp)              /* $0 */
-        br      ret_to_kernel
-.end kernel_thread
+.end    ret_from_kernel_execve
 
 
 /*
@@ -745,15 +721,6 @@ sys_rt_sigreturn:
 .end sys_rt_sigreturn
 
         .align  4
-        .globl  sys_execve
-        .ent    sys_execve
-sys_execve:
-        .prologue 0
-        mov     $sp, $19
-        jmp     $31, do_sys_execve
-.end sys_execve
-
-        .align  4
         .globl  alpha_ni_syscall
         .ent    alpha_ni_syscall
 alpha_ni_syscall:
diff --git a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c
index 83638aa096d5..4054e0ffe2b2 100644
--- a/arch/alpha/kernel/process.c
+++ b/arch/alpha/kernel/process.c
@@ -263,33 +263,35 @@ alpha_vfork(struct pt_regs *regs)
 
 /*
  * Copy an alpha thread..
- *
- * Note the "stack_offset" stuff: when returning to kernel mode, we need
- * to have some extra stack-space for the kernel stack that still exists
- * after the "ret_from_fork".  When returning to user mode, we only want
- * the space needed by the syscall stack frame (ie "struct pt_regs").
- * Use the passed "regs" pointer to determine how much space we need
- * for a kernel fork().
  */
 
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-            unsigned long unused,
+            unsigned long arg,
             struct task_struct * p, struct pt_regs * regs)
 {
         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;
-        struct switch_stack * childstack, *stack;
-        unsigned long stack_offset, settls;
-
-        stack_offset = PAGE_SIZE - sizeof(struct pt_regs);
-        if (!(regs->ps & 8))
-                stack_offset = (PAGE_SIZE-1) & (unsigned long) regs;
-        childregs = (struct pt_regs *)
-          (stack_offset + PAGE_SIZE + task_stack_page(p));
-                
+        struct pt_regs *childregs = task_pt_regs(p);
+        struct switch_stack *childstack, *stack;
+        unsigned long settls;
+
+        childstack = ((struct switch_stack *) childregs) - 1;
+        if (unlikely(!regs)) {
+                /* kernel thread */
+                memset(childstack, 0,
+                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
+                childstack->r26 = (unsigned long) ret_from_kernel_thread;
+                childstack->r9 = usp;   /* function */
+                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;
+        }
         *childregs = *regs;
         settls = regs->r20;
         childregs->r0 = 0;
@@ -297,7 +299,6 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
         childregs->r20 = 1;     /* OSF/1 has some strange fork() semantics.  */
         regs->r20 = 0;
         stack = ((struct switch_stack *) regs) - 1;
-        childstack = ((struct switch_stack *) childregs) - 1;
         *childstack = *stack;
         childstack->r26 = (unsigned long) ret_from_fork;
         childti->pcb.usp = usp;
@@ -386,27 +387,6 @@ dump_elf_task_fp(elf_fpreg_t *dest, struct task_struct *task)
 EXPORT_SYMBOL(dump_elf_task_fp);
 
 /*
- * sys_execve() executes a new program.
- */
-asmlinkage int
-do_sys_execve(const char __user *ufilename,
-              const char __user *const __user *argv,
-              const char __user *const __user *envp, struct pt_regs *regs)
-{
-        int error;
-        char *filename;
-
-        filename = getname(ufilename);
-        error = PTR_ERR(filename);
-        if (IS_ERR(filename))
-                goto out;
-        error = do_execve(filename, argv, envp, regs);
-        putname(filename);
-out:
-        return error;
-}
-
-/*
  * Return saved PC of a blocked thread.  This assumes the frame
  * pointer is the 6th saved long on the kernel stack and that the
  * saved return address is the first long in the frame.  This all
@@ -459,22 +439,3 @@ get_wchan(struct task_struct *p)
         }
         return pc;
 }
-
-int kernel_execve(const char *path, const char *const argv[], const char *const envp[])
-{
-        /* Avoid the HAE being gratuitously wrong, which would cause us
-           to do the whole turn off interrupts thing and restore it.  */
-        struct pt_regs regs = {.hae = alpha_mv.hae_cache};
-        int err = do_execve(path, argv, envp, &regs);
-        if (!err) {
-                struct pt_regs *p = current_pt_regs();
-                /* copy regs to normal position and off to userland we go... */
-                *p = regs;
-                __asm__ __volatile__ (
-                        "mov    %0, $sp;"
-                        "br     $31, ret_from_sys_call"
-                        : : "r"(p));
-        }
-        return err;
-}
-EXPORT_SYMBOL(kernel_execve);