dump_stack: unify debug information printed by show_regs()
[linux-3.10.git] / arch / alpha / kernel / process.c
index 6b33ecd..ab80a80 100644 (file)
@@ -28,6 +28,7 @@
 #include <linux/tty.h>
 #include <linux/console.h>
 #include <linux/slab.h>
+#include <linux/rcupdate.h>
 
 #include <asm/reg.h>
 #include <asm/uaccess.h>
 void (*pm_power_off)(void) = machine_power_off;
 EXPORT_SYMBOL(pm_power_off);
 
-void
-cpu_idle(void)
-{
-       set_thread_flag(TIF_POLLING_NRFLAG);
-
-       while (1) {
-               /* FIXME -- EV6 and LCA45 know how to power down
-                  the CPU.  */
-
-               while (!need_resched())
-                       cpu_relax();
-               schedule();
-       }
-}
-
-
 struct halt_info {
        int mode;
        char *restart_cmd;
@@ -190,6 +175,7 @@ machine_power_off(void)
 void
 show_regs(struct pt_regs *regs)
 {
+       show_regs_print_info(KERN_DEFAULT);
        dik_show_regs(regs, NULL);
 }
 
@@ -231,51 +217,27 @@ 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));
@@ -284,12 +246,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.  */
@@ -297,22 +264,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;
 }
 
@@ -435,22 +386,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);