dump_stack: unify debug information printed by show_regs()
[linux-3.10.git] / arch / m32r / kernel / process.c
index 384e63f..e69221d 100644 (file)
@@ -44,59 +44,9 @@ unsigned long thread_saved_pc(struct task_struct *tsk)
        return tsk->thread.lr;
 }
 
-/*
- * Powermanagement idle function, if any..
- */
-static void (*pm_idle)(void) = NULL;
-
 void (*pm_power_off)(void) = NULL;
 EXPORT_SYMBOL(pm_power_off);
 
-/*
- * We use this is we don't have any better
- * idle routine..
- */
-static void default_idle(void)
-{
-       /* M32R_FIXME: Please use "cpu_sleep" mode.  */
-       cpu_relax();
-}
-
-/*
- * On SMP it's slightly faster (but much more power-consuming!)
- * to poll the ->work.need_resched flag instead of waiting for the
- * cross-CPU IPI to arrive. Use this option with caution.
- */
-static void poll_idle (void)
-{
-       /* M32R_FIXME */
-       cpu_relax();
-}
-
-/*
- * The idle thread. There's no useful work to be
- * done, so just try to conserve power and have a
- * low exit latency (ie sit in a loop waiting for
- * somebody to say that they'd like to reschedule)
- */
-void cpu_idle (void)
-{
-       /* endless idle loop with no priority at all */
-       while (1) {
-               rcu_idle_enter();
-               while (!need_resched()) {
-                       void (*idle)(void) = pm_idle;
-
-                       if (!idle)
-                               idle = default_idle;
-
-                       idle();
-               }
-               rcu_idle_exit();
-               schedule_preempt_disabled();
-       }
-}
-
 void machine_restart(char *__unused)
 {
 #if defined(CONFIG_PLAT_MAPPI3)
@@ -120,24 +70,11 @@ void machine_power_off(void)
        /* M32R_FIXME */
 }
 
-static int __init idle_setup (char *str)
-{
-       if (!strncmp(str, "poll", 4)) {
-               printk("using poll in idle threads.\n");
-               pm_idle = poll_idle;
-       } else if (!strncmp(str, "sleep", 4)) {
-               printk("using sleep in idle threads.\n");
-               pm_idle = default_idle;
-       }
-
-       return 1;
-}
-
-__setup("idle=", idle_setup);
-
 void show_regs(struct pt_regs * regs)
 {
        printk("\n");
+       show_regs_print_info(KERN_DEFAULT);
+
        printk("BPC[%08lx]:PSW[%08lx]:LR [%08lx]:FP [%08lx]\n", \
          regs->bpc, regs->psw, regs->lr, regs->fp);
        printk("BBPC[%08lx]:BBPSW[%08lx]:SPU[%08lx]:SPI[%08lx]\n", \
@@ -165,41 +102,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 +129,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);
-
-       /* Copy registers */
-       *childregs = *regs;
-
-       childregs->spu = spu;
-       childregs->r0 = 0;      /* Child gets zero as return value */
-       regs->r0 = tsk->pid;
+       extern void ret_from_kernel_thread(void);
+
+       if (unlikely(tsk->flags & PF_KTHREAD)) {
+               memset(childregs, 0, sizeof(struct pt_regs));
+               childregs->psw = M32R_PSW_BIE;
+               childregs->r1 = spu;    /* fn */
+               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;
-       char *filename;
-
-       filename = getname(ufilename);
-       error = PTR_ERR(filename);
-       if (IS_ERR(filename))
-               goto out;
-
-       error = do_execve(filename, uargv, uenvp, &regs);
-       putname(filename);
-out:
-       return error;
-}
-
 /*
  * These bracket the sleeping functions..
  */