linux/arch/sparc/kernel/process_32.c
<<
>>
Prefs
   1/*  linux/arch/sparc/kernel/process.c
   2 *
   3 *  Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net)
   4 *  Copyright (C) 1996 Eddie C. Dost   (ecd@skynet.be)
   5 */
   6
   7/*
   8 * This file handles the architecture-dependent parts of process handling..
   9 */
  10
  11#include <stdarg.h>
  12
  13#include <linux/errno.h>
  14#include <linux/module.h>
  15#include <linux/sched.h>
  16#include <linux/kernel.h>
  17#include <linux/mm.h>
  18#include <linux/stddef.h>
  19#include <linux/ptrace.h>
  20#include <linux/user.h>
  21#include <linux/smp.h>
  22#include <linux/reboot.h>
  23#include <linux/delay.h>
  24#include <linux/pm.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27
  28#include <asm/auxio.h>
  29#include <asm/oplib.h>
  30#include <asm/uaccess.h>
  31#include <asm/page.h>
  32#include <asm/pgalloc.h>
  33#include <asm/pgtable.h>
  34#include <asm/delay.h>
  35#include <asm/processor.h>
  36#include <asm/psr.h>
  37#include <asm/elf.h>
  38#include <asm/prom.h>
  39#include <asm/unistd.h>
  40#include <asm/setup.h>
  41
  42/* 
  43 * Power management idle function 
  44 * Set in pm platform drivers (apc.c and pmc.c)
  45 */
  46void (*pm_idle)(void);
  47EXPORT_SYMBOL(pm_idle);
  48
  49/* 
  50 * Power-off handler instantiation for pm.h compliance
  51 * This is done via auxio, but could be used as a fallback
  52 * handler when auxio is not present-- unused for now...
  53 */
  54void (*pm_power_off)(void) = machine_power_off;
  55EXPORT_SYMBOL(pm_power_off);
  56
  57/*
  58 * sysctl - toggle power-off restriction for serial console 
  59 * systems in machine_power_off()
  60 */
  61int scons_pwroff = 1;
  62
  63extern void fpsave(unsigned long *, unsigned long *, void *, unsigned long *);
  64
  65struct task_struct *last_task_used_math = NULL;
  66struct thread_info *current_set[NR_CPUS];
  67
  68#ifndef CONFIG_SMP
  69
  70#define SUN4C_FAULT_HIGH 100
  71
  72/*
  73 * the idle loop on a Sparc... ;)
  74 */
  75void cpu_idle(void)
  76{
  77        /* endless idle loop with no priority at all */
  78        for (;;) {
  79                if (ARCH_SUN4C) {
  80                        static int count = HZ;
  81                        static unsigned long last_jiffies;
  82                        static unsigned long last_faults;
  83                        static unsigned long fps;
  84                        unsigned long now;
  85                        unsigned long faults;
  86
  87                        extern unsigned long sun4c_kernel_faults;
  88                        extern void sun4c_grow_kernel_ring(void);
  89
  90                        local_irq_disable();
  91                        now = jiffies;
  92                        count -= (now - last_jiffies);
  93                        last_jiffies = now;
  94                        if (count < 0) {
  95                                count += HZ;
  96                                faults = sun4c_kernel_faults;
  97                                fps = (fps + (faults - last_faults)) >> 1;
  98                                last_faults = faults;
  99#if 0
 100                                printk("kernel faults / second = %ld\n", fps);
 101#endif
 102                                if (fps >= SUN4C_FAULT_HIGH) {
 103                                        sun4c_grow_kernel_ring();
 104                                }
 105                        }
 106                        local_irq_enable();
 107                }
 108
 109                if (pm_idle) {
 110                        while (!need_resched())
 111                                (*pm_idle)();
 112                } else {
 113                        while (!need_resched())
 114                                cpu_relax();
 115                }
 116                schedule_preempt_disabled();
 117                check_pgt_cache();
 118        }
 119}
 120
 121#else
 122
 123/* This is being executed in task 0 'user space'. */
 124void cpu_idle(void)
 125{
 126        set_thread_flag(TIF_POLLING_NRFLAG);
 127        /* endless idle loop with no priority at all */
 128        while(1) {
 129#ifdef CONFIG_SPARC_LEON
 130                if (pm_idle) {
 131                        while (!need_resched())
 132                                (*pm_idle)();
 133                } else
 134#endif
 135                {
 136                        while (!need_resched())
 137                                cpu_relax();
 138                }
 139                schedule_preempt_disabled();
 140                check_pgt_cache();
 141        }
 142}
 143
 144#endif
 145
 146/* XXX cli/sti -> local_irq_xxx here, check this works once SMP is fixed. */
 147void machine_halt(void)
 148{
 149        local_irq_enable();
 150        mdelay(8);
 151        local_irq_disable();
 152        prom_halt();
 153        panic("Halt failed!");
 154}
 155
 156void machine_restart(char * cmd)
 157{
 158        char *p;
 159        
 160        local_irq_enable();
 161        mdelay(8);
 162        local_irq_disable();
 163
 164        p = strchr (reboot_command, '\n');
 165        if (p) *p = 0;
 166        if (cmd)
 167                prom_reboot(cmd);
 168        if (*reboot_command)
 169                prom_reboot(reboot_command);
 170        prom_feval ("reset");
 171        panic("Reboot failed!");
 172}
 173
 174void machine_power_off(void)
 175{
 176        if (auxio_power_register &&
 177            (strcmp(of_console_device->type, "serial") || scons_pwroff))
 178                *auxio_power_register |= AUXIO_POWER_OFF;
 179        machine_halt();
 180}
 181
 182#if 0
 183
 184static DEFINE_SPINLOCK(sparc_backtrace_lock);
 185
 186void __show_backtrace(unsigned long fp)
 187{
 188        struct reg_window32 *rw;
 189        unsigned long flags;
 190        int cpu = smp_processor_id();
 191
 192        spin_lock_irqsave(&sparc_backtrace_lock, flags);
 193
 194        rw = (struct reg_window32 *)fp;
 195        while(rw && (((unsigned long) rw) >= PAGE_OFFSET) &&
 196            !(((unsigned long) rw) & 0x7)) {
 197                printk("CPU[%d]: ARGS[%08lx,%08lx,%08lx,%08lx,%08lx,%08lx] "
 198                       "FP[%08lx] CALLER[%08lx]: ", cpu,
 199                       rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 200                       rw->ins[4], rw->ins[5],
 201                       rw->ins[6],
 202                       rw->ins[7]);
 203                printk("%pS\n", (void *) rw->ins[7]);
 204                rw = (struct reg_window32 *) rw->ins[6];
 205        }
 206        spin_unlock_irqrestore(&sparc_backtrace_lock, flags);
 207}
 208
 209#define __SAVE __asm__ __volatile__("save %sp, -0x40, %sp\n\t")
 210#define __RESTORE __asm__ __volatile__("restore %g0, %g0, %g0\n\t")
 211#define __GET_FP(fp) __asm__ __volatile__("mov %%i6, %0" : "=r" (fp))
 212
 213void show_backtrace(void)
 214{
 215        unsigned long fp;
 216
 217        __SAVE; __SAVE; __SAVE; __SAVE;
 218        __SAVE; __SAVE; __SAVE; __SAVE;
 219        __RESTORE; __RESTORE; __RESTORE; __RESTORE;
 220        __RESTORE; __RESTORE; __RESTORE; __RESTORE;
 221
 222        __GET_FP(fp);
 223
 224        __show_backtrace(fp);
 225}
 226
 227#ifdef CONFIG_SMP
 228void smp_show_backtrace_all_cpus(void)
 229{
 230        xc0((smpfunc_t) show_backtrace);
 231        show_backtrace();
 232}
 233#endif
 234
 235void show_stackframe(struct sparc_stackf *sf)
 236{
 237        unsigned long size;
 238        unsigned long *stk;
 239        int i;
 240
 241        printk("l0: %08lx l1: %08lx l2: %08lx l3: %08lx "
 242               "l4: %08lx l5: %08lx l6: %08lx l7: %08lx\n",
 243               sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
 244               sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
 245        printk("i0: %08lx i1: %08lx i2: %08lx i3: %08lx "
 246               "i4: %08lx i5: %08lx fp: %08lx i7: %08lx\n",
 247               sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
 248               sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
 249        printk("sp: %08lx x0: %08lx x1: %08lx x2: %08lx "
 250               "x3: %08lx x4: %08lx x5: %08lx xx: %08lx\n",
 251               (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
 252               sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
 253               sf->xxargs[0]);
 254        size = ((unsigned long)sf->fp) - ((unsigned long)sf);
 255        size -= STACKFRAME_SZ;
 256        stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
 257        i = 0;
 258        do {
 259                printk("s%d: %08lx\n", i++, *stk++);
 260        } while ((size -= sizeof(unsigned long)));
 261}
 262#endif
 263
 264void show_regs(struct pt_regs *r)
 265{
 266        struct reg_window32 *rw = (struct reg_window32 *) r->u_regs[14];
 267
 268        printk("PSR: %08lx PC: %08lx NPC: %08lx Y: %08lx    %s\n",
 269               r->psr, r->pc, r->npc, r->y, print_tainted());
 270        printk("PC: <%pS>\n", (void *) r->pc);
 271        printk("%%G: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 272               r->u_regs[0], r->u_regs[1], r->u_regs[2], r->u_regs[3],
 273               r->u_regs[4], r->u_regs[5], r->u_regs[6], r->u_regs[7]);
 274        printk("%%O: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 275               r->u_regs[8], r->u_regs[9], r->u_regs[10], r->u_regs[11],
 276               r->u_regs[12], r->u_regs[13], r->u_regs[14], r->u_regs[15]);
 277        printk("RPC: <%pS>\n", (void *) r->u_regs[15]);
 278
 279        printk("%%L: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 280               rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3],
 281               rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
 282        printk("%%I: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 283               rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 284               rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
 285}
 286
 287/*
 288 * The show_stack is an external API which we do not use ourselves.
 289 * The oops is printed in die_if_kernel.
 290 */
 291void show_stack(struct task_struct *tsk, unsigned long *_ksp)
 292{
 293        unsigned long pc, fp;
 294        unsigned long task_base;
 295        struct reg_window32 *rw;
 296        int count = 0;
 297
 298        if (tsk != NULL)
 299                task_base = (unsigned long) task_stack_page(tsk);
 300        else
 301                task_base = (unsigned long) current_thread_info();
 302
 303        fp = (unsigned long) _ksp;
 304        do {
 305                /* Bogus frame pointer? */
 306                if (fp < (task_base + sizeof(struct thread_info)) ||
 307                    fp >= (task_base + (PAGE_SIZE << 1)))
 308                        break;
 309                rw = (struct reg_window32 *) fp;
 310                pc = rw->ins[7];
 311                printk("[%08lx : ", pc);
 312                printk("%pS ] ", (void *) pc);
 313                fp = rw->ins[6];
 314        } while (++count < 16);
 315        printk("\n");
 316}
 317
 318void dump_stack(void)
 319{
 320        unsigned long *ksp;
 321
 322        __asm__ __volatile__("mov       %%fp, %0"
 323                             : "=r" (ksp));
 324        show_stack(current, ksp);
 325}
 326
 327EXPORT_SYMBOL(dump_stack);
 328
 329/*
 330 * Note: sparc64 has a pretty intricated thread_saved_pc, check it out.
 331 */
 332unsigned long thread_saved_pc(struct task_struct *tsk)
 333{
 334        return task_thread_info(tsk)->kpc;
 335}
 336
 337/*
 338 * Free current thread data structures etc..
 339 */
 340void exit_thread(void)
 341{
 342#ifndef CONFIG_SMP
 343        if(last_task_used_math == current) {
 344#else
 345        if (test_thread_flag(TIF_USEDFPU)) {
 346#endif
 347                /* Keep process from leaving FPU in a bogon state. */
 348                put_psr(get_psr() | PSR_EF);
 349                fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 350                       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 351#ifndef CONFIG_SMP
 352                last_task_used_math = NULL;
 353#else
 354                clear_thread_flag(TIF_USEDFPU);
 355#endif
 356        }
 357}
 358
 359void flush_thread(void)
 360{
 361        current_thread_info()->w_saved = 0;
 362
 363#ifndef CONFIG_SMP
 364        if(last_task_used_math == current) {
 365#else
 366        if (test_thread_flag(TIF_USEDFPU)) {
 367#endif
 368                /* Clean the fpu. */
 369                put_psr(get_psr() | PSR_EF);
 370                fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 371                       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 372#ifndef CONFIG_SMP
 373                last_task_used_math = NULL;
 374#else
 375                clear_thread_flag(TIF_USEDFPU);
 376#endif
 377        }
 378
 379        /* This task is no longer a kernel thread. */
 380        if (current->thread.flags & SPARC_FLAG_KTHREAD) {
 381                current->thread.flags &= ~SPARC_FLAG_KTHREAD;
 382
 383                /* We must fixup kregs as well. */
 384                /* XXX This was not fixed for ti for a while, worked. Unused? */
 385                current->thread.kregs = (struct pt_regs *)
 386                    (task_stack_page(current) + (THREAD_SIZE - TRACEREG_SZ));
 387        }
 388}
 389
 390static inline struct sparc_stackf __user *
 391clone_stackframe(struct sparc_stackf __user *dst,
 392                 struct sparc_stackf __user *src)
 393{
 394        unsigned long size, fp;
 395        struct sparc_stackf *tmp;
 396        struct sparc_stackf __user *sp;
 397
 398        if (get_user(tmp, &src->fp))
 399                return NULL;
 400
 401        fp = (unsigned long) tmp;
 402        size = (fp - ((unsigned long) src));
 403        fp = (unsigned long) dst;
 404        sp = (struct sparc_stackf __user *)(fp - size); 
 405
 406        /* do_fork() grabs the parent semaphore, we must release it
 407         * temporarily so we can build the child clone stack frame
 408         * without deadlocking.
 409         */
 410        if (__copy_user(sp, src, size))
 411                sp = NULL;
 412        else if (put_user(fp, &sp->fp))
 413                sp = NULL;
 414
 415        return sp;
 416}
 417
 418asmlinkage int sparc_do_fork(unsigned long clone_flags,
 419                             unsigned long stack_start,
 420                             struct pt_regs *regs,
 421                             unsigned long stack_size)
 422{
 423        unsigned long parent_tid_ptr, child_tid_ptr;
 424        unsigned long orig_i1 = regs->u_regs[UREG_I1];
 425        long ret;
 426
 427        parent_tid_ptr = regs->u_regs[UREG_I2];
 428        child_tid_ptr = regs->u_regs[UREG_I4];
 429
 430        ret = do_fork(clone_flags, stack_start,
 431                      regs, stack_size,
 432                      (int __user *) parent_tid_ptr,
 433                      (int __user *) child_tid_ptr);
 434
 435        /* If we get an error and potentially restart the system
 436         * call, we're screwed because copy_thread() clobbered
 437         * the parent's %o1.  So detect that case and restore it
 438         * here.
 439         */
 440        if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK)
 441                regs->u_regs[UREG_I1] = orig_i1;
 442
 443        return ret;
 444}
 445
 446/* Copy a Sparc thread.  The fork() return value conventions
 447 * under SunOS are nothing short of bletcherous:
 448 * Parent -->  %o0 == childs  pid, %o1 == 0
 449 * Child  -->  %o0 == parents pid, %o1 == 1
 450 *
 451 * NOTE: We have a separate fork kpsr/kwim because
 452 *       the parent could change these values between
 453 *       sys_fork invocation and when we reach here
 454 *       if the parent should sleep while trying to
 455 *       allocate the task_struct and kernel stack in
 456 *       do_fork().
 457 * XXX See comment above sys_vfork in sparc64. todo.
 458 */
 459extern void ret_from_fork(void);
 460
 461int copy_thread(unsigned long clone_flags, unsigned long sp,
 462                unsigned long unused,
 463                struct task_struct *p, struct pt_regs *regs)
 464{
 465        struct thread_info *ti = task_thread_info(p);
 466        struct pt_regs *childregs;
 467        char *new_stack;
 468
 469#ifndef CONFIG_SMP
 470        if(last_task_used_math == current) {
 471#else
 472        if (test_thread_flag(TIF_USEDFPU)) {
 473#endif
 474                put_psr(get_psr() | PSR_EF);
 475                fpsave(&p->thread.float_regs[0], &p->thread.fsr,
 476                       &p->thread.fpqueue[0], &p->thread.fpqdepth);
 477#ifdef CONFIG_SMP
 478                clear_thread_flag(TIF_USEDFPU);
 479#endif
 480        }
 481
 482        /*
 483         *  p->thread_info         new_stack   childregs
 484         *  !                      !           !             {if(PSR_PS) }
 485         *  V                      V (stk.fr.) V  (pt_regs)  { (stk.fr.) }
 486         *  +----- - - - - - ------+===========+============={+==========}+
 487         */
 488        new_stack = task_stack_page(p) + THREAD_SIZE;
 489        if (regs->psr & PSR_PS)
 490                new_stack -= STACKFRAME_SZ;
 491        new_stack -= STACKFRAME_SZ + TRACEREG_SZ;
 492        memcpy(new_stack, (char *)regs - STACKFRAME_SZ, STACKFRAME_SZ + TRACEREG_SZ);
 493        childregs = (struct pt_regs *) (new_stack + STACKFRAME_SZ);
 494
 495        /*
 496         * A new process must start with interrupts closed in 2.5,
 497         * because this is how Mingo's scheduler works (see schedule_tail
 498         * and finish_arch_switch). If we do not do it, a timer interrupt hits
 499         * before we unlock, attempts to re-take the rq->lock, and then we die.
 500         * Thus, kpsr|=PSR_PIL.
 501         */
 502        ti->ksp = (unsigned long) new_stack;
 503        ti->kpc = (((unsigned long) ret_from_fork) - 0x8);
 504        ti->kpsr = current->thread.fork_kpsr | PSR_PIL;
 505        ti->kwim = current->thread.fork_kwim;
 506
 507        if(regs->psr & PSR_PS) {
 508                extern struct pt_regs fake_swapper_regs;
 509
 510                p->thread.kregs = &fake_swapper_regs;
 511                new_stack += STACKFRAME_SZ + TRACEREG_SZ;
 512                childregs->u_regs[UREG_FP] = (unsigned long) new_stack;
 513                p->thread.flags |= SPARC_FLAG_KTHREAD;
 514                p->thread.current_ds = KERNEL_DS;
 515                memcpy(new_stack, (void *)regs->u_regs[UREG_FP], STACKFRAME_SZ);
 516                childregs->u_regs[UREG_G6] = (unsigned long) ti;
 517        } else {
 518                p->thread.kregs = childregs;
 519                childregs->u_regs[UREG_FP] = sp;
 520                p->thread.flags &= ~SPARC_FLAG_KTHREAD;
 521                p->thread.current_ds = USER_DS;
 522
 523                if (sp != regs->u_regs[UREG_FP]) {
 524                        struct sparc_stackf __user *childstack;
 525                        struct sparc_stackf __user *parentstack;
 526
 527                        /*
 528                         * This is a clone() call with supplied user stack.
 529                         * Set some valid stack frames to give to the child.
 530                         */
 531                        childstack = (struct sparc_stackf __user *)
 532                                (sp & ~0xfUL);
 533                        parentstack = (struct sparc_stackf __user *)
 534                                regs->u_regs[UREG_FP];
 535
 536#if 0
 537                        printk("clone: parent stack:\n");
 538                        show_stackframe(parentstack);
 539#endif
 540
 541                        childstack = clone_stackframe(childstack, parentstack);
 542                        if (!childstack)
 543                                return -EFAULT;
 544
 545#if 0
 546                        printk("clone: child stack:\n");
 547                        show_stackframe(childstack);
 548#endif
 549
 550                        childregs->u_regs[UREG_FP] = (unsigned long)childstack;
 551                }
 552        }
 553
 554#ifdef CONFIG_SMP
 555        /* FPU must be disabled on SMP. */
 556        childregs->psr &= ~PSR_EF;
 557#endif
 558
 559        /* Set the return value for the child. */
 560        childregs->u_regs[UREG_I0] = current->pid;
 561        childregs->u_regs[UREG_I1] = 1;
 562
 563        /* Set the return value for the parent. */
 564        regs->u_regs[UREG_I1] = 0;
 565
 566        if (clone_flags & CLONE_SETTLS)
 567                childregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
 568
 569        return 0;
 570}
 571
 572/*
 573 * fill in the fpu structure for a core dump.
 574 */
 575int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
 576{
 577        if (used_math()) {
 578                memset(fpregs, 0, sizeof(*fpregs));
 579                fpregs->pr_q_entrysize = 8;
 580                return 1;
 581        }
 582#ifdef CONFIG_SMP
 583        if (test_thread_flag(TIF_USEDFPU)) {
 584                put_psr(get_psr() | PSR_EF);
 585                fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 586                       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 587                if (regs != NULL) {
 588                        regs->psr &= ~(PSR_EF);
 589                        clear_thread_flag(TIF_USEDFPU);
 590                }
 591        }
 592#else
 593        if (current == last_task_used_math) {
 594                put_psr(get_psr() | PSR_EF);
 595                fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 596                       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 597                if (regs != NULL) {
 598                        regs->psr &= ~(PSR_EF);
 599                        last_task_used_math = NULL;
 600                }
 601        }
 602#endif
 603        memcpy(&fpregs->pr_fr.pr_regs[0],
 604               &current->thread.float_regs[0],
 605               (sizeof(unsigned long) * 32));
 606        fpregs->pr_fsr = current->thread.fsr;
 607        fpregs->pr_qcnt = current->thread.fpqdepth;
 608        fpregs->pr_q_entrysize = 8;
 609        fpregs->pr_en = 1;
 610        if(fpregs->pr_qcnt != 0) {
 611                memcpy(&fpregs->pr_q[0],
 612                       &current->thread.fpqueue[0],
 613                       sizeof(struct fpq) * fpregs->pr_qcnt);
 614        }
 615        /* Zero out the rest. */
 616        memset(&fpregs->pr_q[fpregs->pr_qcnt], 0,
 617               sizeof(struct fpq) * (32 - fpregs->pr_qcnt));
 618        return 1;
 619}
 620
 621/*
 622 * sparc_execve() executes a new program after the asm stub has set
 623 * things up for us.  This should basically do what I want it to.
 624 */
 625asmlinkage int sparc_execve(struct pt_regs *regs)
 626{
 627        int error, base = 0;
 628        char *filename;
 629
 630        /* Check for indirect call. */
 631        if(regs->u_regs[UREG_G1] == 0)
 632                base = 1;
 633
 634        filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
 635        error = PTR_ERR(filename);
 636        if(IS_ERR(filename))
 637                goto out;
 638        error = do_execve(filename,
 639                          (const char __user *const  __user *)
 640                          regs->u_regs[base + UREG_I1],
 641                          (const char __user *const  __user *)
 642                          regs->u_regs[base + UREG_I2],
 643                          regs);
 644        putname(filename);
 645out:
 646        return error;
 647}
 648
 649/*
 650 * This is the mechanism for creating a new kernel thread.
 651 *
 652 * NOTE! Only a kernel-only process(ie the swapper or direct descendants
 653 * who haven't done an "execve()") should use this: it will work within
 654 * a system call from a "real" process, but the process memory space will
 655 * not be freed until both the parent and the child have exited.
 656 */
 657pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 658{
 659        long retval;
 660
 661        __asm__ __volatile__("mov %4, %%g2\n\t"    /* Set aside fn ptr... */
 662                             "mov %5, %%g3\n\t"    /* and arg. */
 663                             "mov %1, %%g1\n\t"
 664                             "mov %2, %%o0\n\t"    /* Clone flags. */
 665                             "mov 0, %%o1\n\t"     /* usp arg == 0 */
 666                             "t 0x10\n\t"          /* Linux/Sparc clone(). */
 667                             "cmp %%o1, 0\n\t"
 668                             "be 1f\n\t"           /* The parent, just return. */
 669                             " nop\n\t"            /* Delay slot. */
 670                             "jmpl %%g2, %%o7\n\t" /* Call the function. */
 671                             " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */
 672                             "mov %3, %%g1\n\t"
 673                             "t 0x10\n\t"          /* Linux/Sparc exit(). */
 674                             /* Notreached by child. */
 675                             "1: mov %%o0, %0\n\t" :
 676                             "=r" (retval) :
 677                             "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
 678                             "i" (__NR_exit),  "r" (fn), "r" (arg) :
 679                             "g1", "g2", "g3", "o0", "o1", "memory", "cc");
 680        return retval;
 681}
 682EXPORT_SYMBOL(kernel_thread);
 683
 684unsigned long get_wchan(struct task_struct *task)
 685{
 686        unsigned long pc, fp, bias = 0;
 687        unsigned long task_base = (unsigned long) task;
 688        unsigned long ret = 0;
 689        struct reg_window32 *rw;
 690        int count = 0;
 691
 692        if (!task || task == current ||
 693            task->state == TASK_RUNNING)
 694                goto out;
 695
 696        fp = task_thread_info(task)->ksp + bias;
 697        do {
 698                /* Bogus frame pointer? */
 699                if (fp < (task_base + sizeof(struct thread_info)) ||
 700                    fp >= (task_base + (2 * PAGE_SIZE)))
 701                        break;
 702                rw = (struct reg_window32 *) fp;
 703                pc = rw->ins[7];
 704                if (!in_sched_functions(pc)) {
 705                        ret = pc;
 706                        goto out;
 707                }
 708                fp = rw->ins[6] + bias;
 709        } while (++count < 16);
 710
 711out:
 712        return ret;
 713}
 714
 715